com.novartis.opensource.yada.YADARequest Maven / Gradle / Ivy

Go to download
/**
 * Copyright 2016 Novartis Institutes for BioMedical Research Inc.
 * 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 com.novartis.opensource.yada;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItem;
import org.apache.commons.lang.ArrayUtils;
import org.apache.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.novartis.opensource.yada.adaptor.FileSystemAdaptor;
import com.novartis.opensource.yada.plugin.Bypass;
import com.novartis.opensource.yada.plugin.EmailBypassPlugin;
import com.novartis.opensource.yada.plugin.Postprocess;
import com.novartis.opensource.yada.plugin.Preprocess;
import com.novartis.opensource.yada.plugin.ScriptBypass;
import com.novartis.opensource.yada.plugin.ScriptPostprocessor;
import com.novartis.opensource.yada.plugin.ScriptPreprocessor;
import com.novartis.opensource.yada.util.YADAUtils;

/**
 * A utility class for marshalling url params into instance variables, and serving as a portable 
 * structure for passing parameter values across layers of the API. This class also sets default YADA 
 * parameter values, converts values into appropriate object types, or nestles values in data structures.
 * 
 * @author David Varon
 * @since 0.1.0.0
 *
 */
public class YADARequest {

	/**
	 * Local logger hangle
	 */
	private static Logger l = Logger.getLogger(YADARequest.class);
	// constants
	/**
	 * A constant equal to: {@value}. This is the default value for the {@code method} or {@code m} parameter.
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String METHOD_GET 				= "get";
	/**
	 * A constant equal to: {@value}. This value is still necessary for backward compatiblity when expecting
	 * an update query to return an integer result, rather than a JSON object.
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String METHOD_UPDATE 			= "update";
	/**
	 * A constant equal to: {@value}. 
	 * @deprecated as of 0.4.0.0, as this is now detected automatically.
	 */
	@Deprecated
	public static final String METHOD_UPLOAD 			= "upload";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String JSON_KEY_DATA    	= "DATA";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String JSON_KEY_QNAME   	= "qname";
	/**
	 * A constant equal to: {@value}.  This is the default value of the {@code format} or {@code f} parameter.
	 */
	public static final String FORMAT_JSON 				= "json";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_CSV 				= "csv";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_CSV_STRING  = ",";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_TSV 				= "tsv";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_TAB 				= "tab";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_TSV_STRING  = "\t";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_PSV 				= "psv";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_PIPE 				= "pipe";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_PIPE_STRING = "|";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_XML 				= "xml";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_HTML 				= "html";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String FORMAT_DELIMITED   = "delimited";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String SORT_ASC 					= "asc";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String SORT_DESC 					= "desc";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PLUGIN_PKG 				= "com.novartis.opensource.yada.plugin";
	/**
	 * A constant equal to: {@value}.  {@code Override/override} was renamed {@code bypass}
	 */
	@Deprecated
	public static final String OVERRIDE 					= "Override";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 */
	public static final String BYPASS             = "Bypass";
	/**
	 * A constant equal to: {@value}.  Included here for consistency. Use {@code QUERY_BYPASS} instead.
	 * @since 0.4.0.0
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String QUERY_OVERRIDE  	  = "QueryBypass";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 * @deprecated as of 0.4.2.0
	 */
	@Deprecated
	public static final String QUERY_BYPASS    	  = "QueryBypass";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 */
	public static final String OVERRIDE_LC 				= "override";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PREPROCESS 				= "Preprocess";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PREPROCESS_LC			= "preprocess";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String POSTPROCESS 				= "Postprocess";
	/**
	 * A constant equal to: {@value}
	 */
	@Deprecated
	public static final String QUERY_POSTPROCESS 	= "QueryPostprocess";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String POSTPROCESS_LC			= "postprocess";
	/**
	 * A constant equal to: {@value}.  This is the default value for the {@code qname} or {@code q} parameter.
	 * If this value is passed for {@code qname} or {@code q}, and there is no {@code plugin} or {@code pl} 
	 * parameter in the request query string, YADA will return an error.
	 */
	public static final String DEFAULT_QNAME 			= "YADA dummy";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String DEFAULT_USER 			= "YADABOT";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String DEFAULT_DELIMITER  = ",";
	/**
	 * A constant equal to: {@value} (newline)
	 */
	public static final String DEFAULT_ROW_DELIMITER = "\n";
	/**
	 * A constant equal to: {@value}
	 */
	//TODO make PARAM_DELIMITER a settable value
	public static final String PARAM_DELIMITER		= ",";
	/**
	 * A constant equal to: {@value}
	 */
	public static final int    DEFAULT_START_PAGE = 1;
	/**
	 * A constant equal to: {@value}
	 */
	public static final int    DEFAULT_PAGE_SIZE 	= 20;
	/**
	 * A constant equal to: {@value}
	 */
	public static final int    MAX_PAGE_SIZE    	= 1000000000;
	/**
	 * A constant equal to: {@code com.novartis.opensource.yada.plugin.ScriptPreprocessor}
	 */
	public static final String SCRIPT_PREPROCESSOR  = ScriptPreprocessor.class.getName();
	/**
	 * A constant equal to: {@code com.novartis.opensource.yada.plugin.ScriptPostprocessor}
	 */
	public static final String SCRIPT_POSTPROCESSOR = ScriptPostprocessor.class.getName();
	/**
	 * A constant equal to: {@code com.novartis.opensource.yada.plugin.ScriptBypass}
	 */
	public static final String SCRIPT_BYPASS        = ScriptBypass.class.getName();
	
	
	// PL = Param Long
	// PS = Param Short
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_ARGS        = "a";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_BYPASSARGS  = "b";
	/**
   * A constant equal to: {@value}
   * @since 0.5.1.0
   */
  public static final String PS_COMPACT     = "cm";
	/**
   * A constant equal to: {@value}
   * @since PROVISIONAL
   */
	public static final String PS_COOKIES     = "ck";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@code true}.
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_COUNT       = "c";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_COMMITQUERY = "cq";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@code false}.
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_COUNTONLY   = "co";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_CONVERTER   = "cv";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#DEFAULT_DELIMITER}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_DELIMITER   = "d";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_EXPORT      = "e";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_EXPORTLIMIT = "el";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@code null}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_FILTERS     = "fi";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#FORMAT_JSON}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_FORMAT      = "f";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_JSONPARAMS  = "j";
	/**
   * A constant equal to: {@value}
   * @since 0.6.2.0
   */
  public static final String PS_JOIN        = "ij";
  /**
   * A constant equal to: {@value}
   * @since 0.6.2.0
   */
  public static final String PS_LEFTJOIN    = "lj";
  /**
   * A constant equal to: {@value}
   * This is a global parameter.
   * The default value associated to this parameter is {@code null}
   * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
   */
	public static final String PS_HARMONYMAP  = "h";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#METHOD_GET}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String PS_METHOD      = "m";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_OVERARGS    = "o";	
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PAGE        = "pg";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@link YADARequest#DEFAULT_PAGE_SIZE}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PAGESIZE    = "pz";
	/**
	 * A constant equal to: {@value}
 	 * This is a global parameter.
	 * The default value associated to this param is {@link YADARequest#DEFAULT_START_PAGE}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PAGESTART   = "pg";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PARAMS      = "p";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PARAMSET    = "ps";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PLUGIN      = "pl";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String PS_PLUGINTYPE  = "pt";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_POSTARGS    = "pa";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PREARGS     = "pr";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PRETTY      = "py";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_PROTOCOL    = "pc";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.1.0
	 */
	public static final String PS_PROXY       = "px";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_QNAME       = "q";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#DEFAULT_ROW_DELIMITER}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_ROW_DELIMITER = "rd";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_RESPONSE    = "r";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value is {@code null}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_SORTKEY     = "s";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@link YADARequest#SORT_ASC}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_SORTORDER   = "so";
	/**
	 * A constant equal to: {@value}
	 * @since 0.5.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_UPDATE_STATS = "us";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_USER        = "u";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0 (Short param aliases were first added in 0.4.0.0)
	 */
	public static final String PS_VIEWLIMIT   = "vl";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_ARGS        = "args";
	/**
	 * A constant equal to: {@value}.  This constant has replaced {@link YADARequest#PL_OVERARGS} to avoid 
	 * java compiler annotation errors with the caused by name conficts, i.e., {@code @Override} 
	 * @since 0.4.0.0
	 */
	public static final String PL_BYPASSARGS  = "bypassargs";
	/**
	 * A constant equal to: {@value}
	 */
	//TODO there is no alias for PL_COLHEAD
	public static final String PL_COLHEAD     = "colhead";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 */
	public static final String PL_COMMITQUERY = "commitQuery";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_COMPACT     = "compact";
	/**
   * A constant equal to: {@value}
   * @since 0.5.1.0
   */
	public static final String PL_COOKIES     = "cookies";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@code true}.
	 * @since 0.1.0.0
	 */
	public static final String PL_COUNT       = "count";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@code false}.
	 * @since 0.2.0.0
	 */
	public static final String PL_COUNTONLY   = "countOnly";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 */
	public static final String PL_CONVERTER   = "converter";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#DEFAULT_DELIMITER}
	 * @since 0.4.0.0
	 */
	public static final String PL_DELIMITER   = "delimiter";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_EXPORT      = "export";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_EXPORTLIMIT = "exportlimit";
	/**
	 * A constant equal to: {@value}
   * This is a global parameter.
	 * The default value associated to this parameter is {@code null}
	 */
	public static final String PL_FILTERS     = "filters";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#FORMAT_JSON}
	 */
	public static final String PL_FORMAT      = "format";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@code null}
	 * @since 0.4.0.0
	 */
	public static final String PL_HARMONYMAP  = "harmonyMap";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_JSONPARAMS  = "JSONParams";
	/**
   * A constant equal to: {@value}
   * @since 0.6.2.0
   */
  public static final String PL_JOIN        = "join";
  /**
   * A constant equal to: {@value}
   * @since 0.6.2.0
   */
  public static final String PL_LEFTJOIN    = "leftJoin";
	/**
	 * A constant equal to: {@value}
	 */
	//TODO There is no alias for PL_LABELS
	public static final String PL_LABELS      = "labels";
	/**
	 * A constant equal to: {@value}
	 */
//TODO There is no alias for PL_MAIL
	public static final String PL_MAIL        = "mail";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#METHOD_GET}
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String PL_METHOD      = "method";
	/**
	 * A constant equal to: {@value}.  Use {@link YADARequest#PL_BYPASSARGS} instead.
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String PL_OVERARGS    = "overargs";
	/**
	 * A constant equal to: {@value}.  Defaults to {@link YADARequest#DEFAULT_START_PAGE}
	 */
	public static final String PL_PAGE        = "page";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@link YADARequest#DEFAULT_PAGE_SIZE}
	 * @since 0.1.0.0
	 */
	public static final String PL_PAGESIZE    = "pagesize";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@link YADARequest#DEFAULT_START_PAGE}
	 * @since 0.1.0.0
	 */
	public static final String PL_PAGESTART   = "pagestart";
	/**
	 * A constant equal to: {@value}
	 * @since 0.1.0.0
	 */
	public static final String PL_PARAMS      = "params";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_PARAMSET    = "paramset";
	/**
	 * A constant equal to: {@value}
	 */
  //TODO There is no alias for PL_PATH
	public static final String PL_PATH        = "path";
	/**
	 * @deprecated as of 0.4.0.0
	 */
  //TODO There is no alias for PL_LABELS
	@Deprecated
	public static final String PL_PARALLEL    = "parallel";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_PLUGIN      = "plugin";
	/**
	 * A constant equal to: {@value}
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public static final String PL_PLUGINTYPE  = "plugintype";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_POSTARGS    = "postargs";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_PREARGS     = "preargs";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_PRETTY      = "pretty";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 */
	public static final String PL_PROTOCOL    = "protocol";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.1.0
	 */
	public static final String PL_PROXY       = "proxy";
	/**
	 * Required.
	 * A constant equal to: {@value}
	 * @since 0.1.0.0
	 */
	public static final String PL_QNAME       = "qname";
	/**
	 * A constant equal to: {@value}
	 * @since 0.4.0.0
	 */
	public static final String PL_RESPONSE    = "response";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this parameter is {@link YADARequest#DEFAULT_ROW_DELIMITER};
	 * @since 0.4.0.0
	 */
	public static final String PL_ROW_DELIMITER = "rowDelimiter";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value is {@code null}
	 * @since 0.1.0.0
	 */
	public static final String PL_SORTKEY     = "sortkey";
	/**
	 * A constant equal to: {@value}
	 * This is a global parameter.
	 * The default value associated to this param is {@link YADARequest#SORT_ASC}
	 * @since 0.1.0.0
	 */
	public static final String PL_SORTORDER   = "sortorder";
	/**
	 * A constant equal to: {@value}
	 * @since 0.5.0.0
	 */
	public static final String PL_UPDATE_STATS = "updateStats";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_USER        = "user";
	/**
	 * A constant equal to: {@value}
	 */
	public static final String PL_VIEWLIMIT   = "viewlimit";
	
	// utility vars
	/**
	 * The calling url
	 */
	private String               referer;
	/**
	 * The request object provided by Tomcat
	 */
	private HttpServletRequest   request;
	/**
	 * The map of parameters derived from the request
	 */
	private Map parameterMap = new LinkedHashMap<>();
	/**
	 * A thesaurus for long and short parameter name synonyms
	 */
	private static final Map fieldAliasMap;
	
	static {
		Map map = new HashMap<>();
		map.put(PS_ARGS,PL_ARGS);
		map.put(PS_BYPASSARGS, PL_BYPASSARGS);
		map.put(PS_COUNT,PL_COUNT);
		map.put(PS_COUNTONLY,PL_COUNTONLY);
		map.put(PS_COMPACT,PL_COMPACT);
		map.put(PS_COMMITQUERY, PL_COMMITQUERY);
		map.put(PS_CONVERTER, PL_CONVERTER);
		map.put(PS_COOKIES, PL_COOKIES);
		map.put(PS_DELIMITER, PL_DELIMITER);
		map.put(PS_ROW_DELIMITER, PL_ROW_DELIMITER);
		map.put(PS_EXPORT,PL_EXPORT);
		map.put(PS_EXPORTLIMIT,PL_EXPORTLIMIT);
		map.put(PS_FILTERS,PL_FILTERS);
		map.put(PS_FORMAT,PL_FORMAT);
		map.put(PS_HARMONYMAP,PL_HARMONYMAP);
		map.put(PS_JSONPARAMS,PL_JSONPARAMS);
		map.put(PS_JOIN, PL_JOIN);
		map.put(PS_LEFTJOIN, PL_LEFTJOIN);
		map.put(PS_METHOD,PL_METHOD);
		map.put(PS_OVERARGS,PL_OVERARGS);
		map.put(PS_PAGE,PL_PAGE);
		map.put(PS_PAGESIZE,PL_PAGESIZE);
		map.put(PS_PAGESTART,PL_PAGESTART);
		map.put(PS_PARAMS,PL_PARAMS);
		map.put(PS_PARAMSET,PL_PARAMSET);
		map.put(PS_PLUGIN,PL_PLUGIN);
		map.put(PS_PLUGINTYPE,PL_PLUGINTYPE);
		map.put(PS_POSTARGS,PL_POSTARGS);
		map.put(PS_PREARGS,PL_PREARGS);
		map.put(PS_PRETTY, PL_PRETTY);
		map.put(PS_PROTOCOL,PL_PROTOCOL);
		map.put(PS_PROXY,PL_PROXY);
		map.put(PS_QNAME,PL_QNAME);
		map.put(PS_RESPONSE, PL_RESPONSE);
		map.put(PS_SORTKEY,PL_SORTKEY);
		map.put(PS_SORTORDER,PL_SORTORDER);
		map.put(PS_UPDATE_STATS, PL_UPDATE_STATS);
		map.put(PS_USER,PL_USER);
		map.put(PS_VIEWLIMIT,PL_VIEWLIMIT);
		map.put(PL_ARGS,PL_ARGS);
		map.put(PL_BYPASSARGS,PL_BYPASSARGS);
		map.put(PL_COLHEAD,PL_COLHEAD);
		map.put(PL_COMPACT,PL_COMPACT);
		map.put(PL_COMMITQUERY, PL_COMMITQUERY);
		map.put(PL_DELIMITER, PL_DELIMITER);
		map.put(PL_ROW_DELIMITER, PL_ROW_DELIMITER);
		map.put(PL_COUNT,PL_COUNT);
		map.put(PL_COUNTONLY,PL_COUNTONLY);
		map.put(PL_CONVERTER, PL_CONVERTER);
		map.put(PL_COOKIES, PL_COOKIES);
		map.put(PL_EXPORT,PL_EXPORT);
		map.put(PL_EXPORTLIMIT,PL_EXPORTLIMIT);
		map.put(PL_FILTERS,PL_FILTERS);
		map.put(PL_FORMAT,PL_FORMAT);
		map.put(PL_HARMONYMAP,PL_HARMONYMAP);
		map.put(PL_JSONPARAMS,PL_JSONPARAMS);
		map.put(PL_JOIN, PL_JOIN);
    map.put(PL_LEFTJOIN, PL_LEFTJOIN);
		map.put(PL_LABELS,PL_LABELS);
		map.put(PL_MAIL,PL_MAIL);
		map.put(PL_METHOD,PL_METHOD);
		map.put(PL_OVERARGS,PL_OVERARGS);
		map.put(PL_PAGE,PL_PAGE);
		map.put(PL_PAGESIZE,PL_PAGESIZE);
		map.put(PL_PAGESTART,PL_PAGESTART);
		map.put(PL_PARAMS,PL_PARAMS);
		map.put(PL_PARAMSET,PL_PARAMSET);
		map.put(PL_PATH,PL_PATH);
		map.put(PL_PARALLEL,PL_PARALLEL);
		map.put(PL_PLUGIN,PL_PLUGIN);
		map.put(PL_PLUGINTYPE,PL_PLUGINTYPE);
		map.put(PL_POSTARGS,PL_POSTARGS);
		map.put(PL_PREARGS,PL_PREARGS);
		map.put(PL_PRETTY,PL_PRETTY);
		map.put(PL_PROTOCOL,PL_PROTOCOL);
		map.put(PL_PROXY, PL_PROXY);
		map.put(PL_RESPONSE, PL_RESPONSE);
		map.put(PL_QNAME,PL_QNAME);
		map.put(PL_SORTKEY,PL_SORTKEY);
		map.put(PL_SORTORDER,PL_SORTORDER);
		map.put(PL_UPDATE_STATS, PL_UPDATE_STATS);
		map.put(PL_USER,PL_USER);
		map.put(PL_VIEWLIMIT,PL_VIEWLIMIT);
		fieldAliasMap = Collections.unmodifiableMap(map);
	}
	
	// URL Parameters
	/**
	 * Flog indicating whether or not to include the column header in delimited output. Defaults to {@code false}.
	 */
	private boolean    colhead      = false;
	/**
	 * Flag indicating whether or not to use compact notation in json results. Defaults to {@code false}
	 * @since PROVISIONAL
	 */
	private boolean    compact      = false;
	/**
	 * Flag indicating whether or not to execute JDBC commits after each query execution. Defaults to {@code false} (request-level commit)
	 */
	private boolean    commitQuery  = false;
	/**
	 * Flag indicating whether or not to execute a second query to return the total number results  
	 */
	private boolean    count        = true;  
	/**
	 * Flag indicating whether or not to execute ONLY the count query, and ignore the data query
	 */
	private boolean    countOnly    = false;
	/**
	 * The character for separating columns in delimited output 
	 */
	private String     delimiter    = DEFAULT_DELIMITER;
	/**
	 * Flag indicating whether or not to automatically dump results to delimited file, and return url to client. Defaults to {@code false}
	 */
	private boolean    export       = false;
	/**
	 * Maxium number of rows to include in export. Defaults to {@code -1}
	 */
	private int        exportLimit  = -1;
	/**
	 * Parsed filter criteria string.
	 */
	private JSONObject filters;
	/**
	 * Response format. Defaults to {@link #FORMAT_JSON}
	 */
	private String     format 	 	  = FORMAT_JSON;
	/**
	 * Parsed harmonyMap string
	 */
	private JSONArray harmonyMap;
	/**
	 * Flag indicating something about labels.
	 * @since PROVISIONAL
	 */
	private boolean    labels       = true;
	/**
	 * Mail specification
	 */
	private String     mail;
	/**
	 * YADA execution method. Defaults to {@link #METHOD_GET}
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	private String     method 	 	  = METHOD_GET;
	/**
	 * Number of rows to return.  Defaults to {@link #DEFAULT_PAGE_SIZE}
	 */
	private int        pageSize 	  = DEFAULT_PAGE_SIZE;
	/**
	 * The "page" subset of results to return (first record = {@code pageSize} * {@code pageStart}). Defaults to {@link #DEFAULT_START_PAGE} 
	 */
	private int        pageStart 	  = DEFAULT_START_PAGE;
	/**
	 * Flag indicating whether to process count query in separate thread.
	 * @deprecated as of 0.4.0.0: Never called.
	 */
	@Deprecated
	private boolean    parallel     = false;
	/**
	 * Container for query data parameter values.
	 */
	private String[][] params		    = null;
	/**
	 * Name of stored parameter set.
	 * @since PROVISIONAL
	 */
	private String     paramset;
	/**
	 * Filesystem location of target. Used by {@link FileSystemAdaptor}
	 */
	private String     path;
	/**
	 * Class name (default package,) or fully-qualified class name of plugin.  Type is auto-detected.
	 */
	private String[]   plugin 	    = null;
	/**
	 * Plugin class type, either {@link #PREPROCESS}, {@link #POSTPROCESS}, or {@link #BYPASS}
	 * @deprecated since 0.4.0.0
	 */
	@Deprecated
	private String[]   pluginType   = {PREPROCESS};
	/**
	 * Flag indicating whether or not to pretty print JSON results
	 */
	private boolean    pretty       = false;
	/**
	 * Connection mode of query, defaults to {@link Parser#JDBC}
	 */
	private String     protocol     = Parser.JDBC;
	/**
	 * The proxy server to use for external REST queries
	 */
	private String     proxy        = null;
	/**
	 * The name of the query to be executed, when coupled with {@link #params}, or {@link #plugin}.  Defaults to {@link #DEFAULT_QNAME}
	 */
	private String     qname 		    = DEFAULT_QNAME;
	/**
	 * The class name or fully-qualified classname of the {@link com.novartis.opensource.yada.format.Response} object desired to be returned.  Default is 
	 * determined dynamically using {@link #format}.
	 */
	private String     response;
	/**
   * The class name or fully-qualified classname of the {@link com.novartis.opensource.yada.format.Converter} object desired to be used to format data results.  Default is 
	 * determined dynamically using {@link #format} and {@link #protocol}
	 */
	private String     converter;
	/**
	 * The character for separating rows in delimited output. Defaults to {@link #DEFAULT_ROW_DELIMITER}
	 */
	private String     rowDelimiter = DEFAULT_ROW_DELIMITER;
	/**
	 * The column on which to sort results
	 */
	private String     sortKey;
	/**
	 * The order of sorted results.  Defaults to {@link #SORT_ASC}
	 */
	private String     sortOrder   	= SORT_ASC;
	/**
	 * Flag indicating whether or not the {@link Finder} should execute a parallel op to update the query access count and date  
	 */
	private boolean    updateStats = true;  
	/**
	 * The id of the requesting user.  Defaults to {@link #DEFAULT_USER}
	 */
	private String     user 		    = DEFAULT_USER;
	/**
	 * The maximum number of rows to return, when distinct from {@link #exportLimit} or {@link #pageSize}.  This is a performance enhancer for very large data sets.
	 */
	private int        viewLimit 	  = -1;
	/**
	 * A data structure for storing json params values
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	private Map>> 
					   JSONParams           = new LinkedHashMap<>();
	/**
	 * A data structure for storing json params values
	 */
	private JSONParams jsonParams;
	/**
	 * A boolean or comma-separated list of names to specify on which fields to join multiple result sets
	 * @since 0.6.2.0
	 */
	private String join = "";
	/**
   * A boolean or comma-separated list of names to specify on which fields to join multiple result sets
   * @since 0.6.2.0
   */
  private String leftJoin = "";
	/**
	 * The list of cookies names passed in the request
	 * @since 0.5.1.0
	 */
	private List cookies    = new ArrayList<>();
	/**
	 * A data structure for storing content and form field values when uploading a file
	 */
	private List uploadItems;
	/**
	 * Plugin arguments
	 */
	private List   args 	  = new ArrayList<>();
	/**
	 * Preprocessor plugin arguments
	 */
	private List   preArgs 	= new ArrayList<>();
	/**
	 * Postprocessor plugin arguments
	 */
	private List   postArgs = new ArrayList<>();
	/**
	 * Bypass plugin arguments
	 */
	private List   bypassArgs = new ArrayList<>();
	
	/**
	 * Default constructor 
	 */
	public YADARequest() {	}
	
	/**
	 * Calls {@link #invokeSetter(String, String)} internally to dynamically map all request parameters
	 * @param paramList a list of parameters to set in this configuration object
	 * @throws YADARequestException when there is a method invocation problem related to a parameter
	 */
	public YADARequest(List paramList) throws YADARequestException {
		for(YADAParam param : paramList)
		{
			this.invokeSetter(param.getName(), param.getValue());
		}
	}
	
	/**
	 * Generates a {@link java.util.List} of {@link YADAParam} objects from request parameter values.  All objects 
	 * are qualified as {@link YADAParam#QUERY}-targeted (as opposed to {@link YADAParam#APP}-targeted), 
	 * and {@link YADAParam#OVERRIDEABLE}
	 * 
	 * @return a list of parameter objects, all overrideable, and query-level, derived from request parameter values
	 * @throws YADARequestException when there is a mal
	 */
	public List getAllParams() throws YADARequestException
	{
		List lParams = new ArrayList<>();
		for (Iterator iterator = fieldAliasMap.keySet().iterator(); iterator.hasNext();)
		{
			String key = iterator.next();
			String val = (String) invokeGetter(key);
			YADAParam param = new YADAParam(key,val,YADAParam.QUERY,YADAParam.OVERRIDEABLE);
			lParams.add(param);
		}
		return lParams;
	}
	
	/**
	 * This is an alias for {@link #getRequestParamsForQueries()}
	 * @return a {@link java.util.List} of {@link YADAParam}s which will be applied to the entire request
	 * @throws YADAQueryConfigurationException when a malformed parameter is encountered
	 * @see #getRequestParamsForQueries()
	 */
	public List getGlobalParamsForQueries() throws YADAQueryConfigurationException
	{
		return getRequestParamsForQueries();
	}
	
	
	/**
	 * Returns a list with the following parameters:
	 * 
	 *   {@link #PS_COUNT}
	 *   {@link #PS_COUNTONLY}
	 *   {@link #PS_DELIMITER}
	 *   {@link #PS_FILTERS}
	 *   {@link #PS_FORMAT}
	 *   {@link #PS_HARMONYMAP}
	 *   {@link #PS_METHOD} (for backward compatibility)
	 *   {@link #PS_PAGESIZE}
	 *   {@link #PS_PAGESTART}
	 *   {@link #PS_ROW_DELIMITER}
	 *   {@link #PS_SORTKEY}
	 *   {@link #PS_SORTORDER}
	 * 
	 * @return a {@link java.util.List} of {@link YADAParam}s which will be applied to the entire request
	 * @throws YADAQueryConfigurationException when a malformed parameter is encountered
	 */
	public List getRequestParamsForQueries() throws YADAQueryConfigurationException
	{
		List lParams = new ArrayList<>();
		JSONObject jobj = new JSONObject();
		try
		{
			jobj.put(PS_COUNT, getCount());
			jobj.put(PS_FILTERS, getFilters());
			jobj.put(PS_PAGESIZE, getPageSize());
			jobj.put(PS_PAGESTART, getPageStart());
			jobj.put(PS_SORTKEY, getSortKey());
			jobj.put(PS_SORTORDER, getSortOrder());
			jobj.put(PS_METHOD, getMethod());
			jobj.put(PS_FORMAT, getFormat());
			jobj.put(PS_DELIMITER, getDelimiter());
			jobj.put(PS_ROW_DELIMITER, getRowDelimiter());
			jobj.put(PS_HARMONYMAP, getHarmonyMap());
			jobj.put(PS_COUNTONLY, getCountOnly());
			jobj.put(PS_UPDATE_STATS, getUpdateStats());
			jobj.put(PS_JOIN, getJoin());
			jobj.put(PS_LEFTJOIN, getLeftJoin());
	
			for(String key : JSONObject.getNames(jobj))
			{
				if(key != null && String.valueOf(jobj.get(key)) != null)
				{
					YADAParam param = new YADAParam(key, 
					                                String.valueOf(jobj.get(key)), 
					                                YADAParam.QUERY, 
					                                YADAParam.OVERRIDEABLE);
					lParams.add(param);
				}
			}
		}
		catch(JSONException e)
		{
			String msg = "Unable to create global parameters list.";
			throw new YADAQueryConfigurationException(msg,e);
		}
		return lParams;
	}
	
	/**
	 * Uses a parameter name fragment to retrieve the desired parameter value regardless of whether a short or long 
	 * parameter name was used in the request.
	 * 
	 * @param q list of parameter objects
	 * @param frag fragment of parameter name to retrieve
	 * @return the value of the desired parameter
	 * @throws YADAQueryConfigurationException when a parameter containing {@code frag} cannot be found
	 */
	public static String getParamValueForKey(List q, String frag) throws YADAQueryConfigurationException 
	{
		//for (Iterator iterator = q.iterator(); iterator.hasNext();)
		for (YADAParam param : q)
		{
			try
			{
				JSONObject j = new JSONObject();
				j.put(param.getName(),param.getValue());
				String key = getParamValueForKey(j,frag);
				if(param.getName().equals(key))
					return param.getValue();
			} 
			catch (JSONException e)
			{
				throw new YADAQueryConfigurationException(e.getMessage(),e);
			}
		}
		return null;
	}
		
	/**
	 * Uses a parameter name fragment to retrieve the desired parameter value regardless of whether a short or long 
	 * parameter name was used in the request.
	 * @param q a JSON object containing parameter object metadata and values
	 * @param frag a parameter name fragment
	 * @return the value of the desired parameter
	 * @throws YADAQueryConfigurationException when a parameter containing {@code frag} cannot be found 
	 */
	public static String getParamValueForKey(JSONObject q, String frag) throws YADAQueryConfigurationException {
		String PL  = "PL_";
		String PS  = "PS_";
		String keys[] = new String[] { PL+frag, PS+frag };
		for (String key : keys)
		{
			try 
			{
				String keyVal = (String) YADARequest.class.getField(key).get(null);
				if(q.has(keyVal))
				{
					try
					{
					  return q.getString(keyVal);
					}
					catch(JSONException e)
					{
					  return q.getJSONObject(keyVal).toString();
					}
				}
			} 
			catch (SecurityException e) 
			{
				throw new YADAQueryConfigurationException(e.getMessage(),e);
			} 
			catch (NoSuchFieldException e) 
			{
				throw new YADAQueryConfigurationException(e.getMessage(),e);
			} 
			catch (IllegalArgumentException e) 
			{
				throw new YADAQueryConfigurationException(e.getMessage(),e);
			} 
			catch (IllegalAccessException e) 
			{
				throw new YADAQueryConfigurationException(e.getMessage(),e);
			}
		}
		return null;
	}
	
	/**
	 * Returns the value of the constant {@code key}.  This is useful when processing {@link YADAUtils#PARAM_FRAGS}.
	 * @param key the name of a constant
	 * @return the value of the constant {@code key}
	 * @throws YADAQueryConfigurationException when {@code key} is not accessible for any reason.
	 */
	public static String getParamKeyVal(String key) throws YADAQueryConfigurationException 
	{
		String val = null;
		try
		{
			val = (String) YADARequest.class.getField(key).get(null); 
		}
		catch (SecurityException e) 
		{
			throw new YADAQueryConfigurationException(e.getMessage(),e);
		} 
		catch (NoSuchFieldException e) 
		{
			throw new YADAQueryConfigurationException(e.getMessage(),e);
		} 
		catch (IllegalArgumentException e) 
		{
			throw new YADAQueryConfigurationException(e.getMessage(),e);
		} 
		catch (IllegalAccessException e) 
		{
			throw new YADAQueryConfigurationException(e.getMessage(),e);
		}
		return val;
	}
	
	/**
	 * Gets the long parameter name mapped to the {@code shortcut} args
	 * @since 0.4.0.0
	 * @param shortcut a short parameter name, i.e., {@code PS_...}
	 * @return {@link String} Long parameter name alias mapped to {@code shortcut}
	 */
	private static String getFieldAlias(String shortcut) {
		return fieldAliasMap.get(shortcut);
	}
	
	/**
	 * Standard mutator for variable
	 * @param request the {@link javax.servlet.http.HttpServletRequest} object passed from the app server
	 */
	public void setRequest(HttpServletRequest request)
	{
		this.request = request;
	}
	
	/**
	 * Standard accessor for variable
	 * @return the {@link javax.servlet.http.HttpServletRequest} object passed from the app server
	 */
	public HttpServletRequest getRequest()
	{
		return this.request;
	}
	
	/* 
	 * Non params, utils
	 */
	/**
	 * Standard mutator for variable
	 * @param referer the referring page
	 */
	public void setReferer(String referer)
	{
		this.referer = referer;
		l.debug(getFormattedDebugString("referer", referer));
	}
	
	/**
	 * Standard accessor for variable
	 * @return the referring url
	 */
	public String getReferer()
	{
		return this.referer;
	}
	
	/**
	 * Standard mutator for variable.  Used by {@code yada.jsp} to pass the application context root to the framework 
	 * to assist with file uploads.
	 * @param path a portion of the requested url
	 */
	public void setPath(String path) {
		this.path = path;
		l.debug(getFormattedDebugString("path", path));
	}
	
	/**
	 * Standard accessor for variable
	 * @return the path value, usually the application context root as set in {@code yada.jsp}
	 */
	public String getPath() {
		return this.path;
	}
	
	/**
	 * Returns a json formatted string derived from {@link #getParameterMap()}
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString()
	{
		l.debug(getParameterMap().toString());
		return new JSONObject(getParameterMap()).toString();
	}
	
	/**
	 * Adds a parameter to the parameter maps
	 * @param key the parameter name
	 * @param value the parameter value
	 */
	public void addToMap(String key, String[] value)
	{
		getParameterMap().put(key,value);
	}
	
	/**
	 * Uses java reflection to invoke the "getter" method associated to the {@code alias} arg.
	 * 
	 * @since 0.4.0.0
	 * @param alias the parameter name
	 * @return Object value of parameter corresponding to getter method 
	 * @throws YADARequestException when method invocation fails
	 */
	public Object invokeGetter(String alias) throws YADARequestException
	{
		// input
		String field = getFieldAlias(alias);
		// return value
		Object o = null;
		// list of methods
		Method[] methods = this.getClass().getMethods();
		// currently inquired method name
		String mName = "set" + field.substring(0, 1).toUpperCase() + field.substring(1);
		// iterate over methods
		for (int i = 0; i < methods.length; i++) 
		{
			String methName = methods[i].getName();
			if(methName.equals(mName))
			{
				l.debug("methName:" + methName + ":" + mName);
				try 
				{
					o = methods[i].invoke(this, new Object[] {});
				} 
				catch (InvocationTargetException e) 
				{
					throw new YADARequestException(e.getMessage(),e);
				} 
				catch (IllegalAccessException e) 
				{
					throw new YADARequestException(e.getMessage(),e);
				}
			}
		}
		return o;
	}
	
	/**
	 * Uses java reflection to invoke the "setter" method associated to {@code alias}
	 * @since 0.4.0.0
	 * @param alias the parameter name
	 * @param value the parameter value(s)
	 * @throws YADARequestException when there is a method invocation problem with the setter for {@code alias} 
	 */
	public void invokeSetter(String alias, String[] value) throws YADARequestException
	{
		//input
		String field = getFieldAlias(alias);
		// list of methods
		Method[] methods = this.getClass().getMethods();
		// currently inquired method name
		String mName = "set" + field.substring(0, 1).toUpperCase() + field.substring(1);
		// iterate over methods
		for (int i = 0; i < methods.length; i++) {
			String methName = methods[i].getName();
			
			if (methName.equals(mName) && methods[i].getParameterTypes()[0].isArray()) {
				l.debug("methName:" + methName + ":" + mName);
				try 
				{
					methods[i].invoke(this, new Object[] {value});
				} 
				catch (InvocationTargetException e) 
				{
					throw new YADARequestException(e.getMessage(),e);
				} 
				catch (IllegalAccessException e) 
				{
					throw new YADARequestException(e.getMessage(),e);
				}
			}
		}
	}
	
	/**
	 * Uses java reflection to invoke the "setter" method associated to {@code alias}
	 * @param alias the parameter name
	 * @param value the parameter value
	 * @throws YADARequestException when there is a method invocation problem with the setter for {@code alias}
	 */
	public void invokeSetter(String alias, String value) throws YADARequestException
	{
		//input
		String field = getFieldAlias(alias);
		// list of methods
		Method[] methods = this.getClass().getMethods();
		// currently inquired method name
		String mName = "set" + field.substring(0, 1).toUpperCase() + field.substring(1);
		// iterate over methods
		for (int i = 0; i < methods.length; i++) {
			String[] arglist = new String[1];
			String methName = methods[i].getName();

			if (methName.equals(mName)) {
				l.debug("methName:" + methName + ":" + mName);
				arglist[0] = value;
				try 
				{
					if(methods[i].getParameterTypes()[0].isArray())
					{
						methods[i].invoke(this, (Object)arglist);
					}
					//l.debug("qname: " + getQname());
				} 
				catch (InvocationTargetException e) 
				{
					throw new YADARequestException(e.getMessage(),e);
				} 
				catch (IllegalAccessException e) 
				{
					throw new YADARequestException(e.getMessage(),e);
				}
			}
		}
	}
	
	/**
	 * Adds a value to the {@code #args} list
	 * @param arg the value to add to the list
	 */
	public void addArg(String arg) {
		this.args.add(arg);
	}

	/**
	 * Adds a value to the {@code #preArgs} list
	 * @param arg the value to add to the list
	 */
	public void addPreArg(String arg) {
		this.preArgs.add(arg);
	}

	/**
	 * Adds a value to the {@code #postArgs} list
	 * @param arg the value to add to the list
	 */

	public void addPostArg(String arg) {
		this.postArgs.add(arg);
	}

	/**
   * Adds a value to the {@code #cookies} list
   * @param cookie the value to add to the list
   * @since 0.5.1.0
   */
  public void addCookie(String cookie) {
    this.cookies.add(cookie);
  }
  
	/**
	 * Adds a value to the {@code #bypassArgs} list
	 * @param arg the value to add to the list
	 * @deprecated use {@link #addBypassArg(String)}
	 */
	@Deprecated
	public void addOverArg(String arg) {
		this.bypassArgs.add(arg);
	}
	
	/**
	 * Adds a value to the {@code #bypassArgs} list
	 * @param arg the value to add to the list
	 */
	public void addBypassArg(String arg) {
		this.bypassArgs.add(arg);
	}

	/*
	 * Parameter Setters
	 */
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0.  Use {@link #setArgs(String[])}.
	 * @param args the list of args to pass to the plugin
	 */
	@Deprecated
	public void setArgs(List args) {
		this.args = args;
		l.debug(getFormattedDebugString("args", args.toString()));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @param argArr the array of args to pass to the plugin
	 */
	public void setArgs(String[] argArr)
	{
		String[] lArgs = argArr[0].split(PARAM_DELIMITER);
		if (lArgs.length > 0)
		{
			for (String arg : lArgs)
			{
				this.addArg(arg);
			}
		}
		l.debug(getFormattedDebugString("args", lArgs.toString()));
	}
	

	
	/**
	 * Sets the column header flag.
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setColhead(String[])} or {@link #setColHead(String[])}
	 * @param colhead flag for inclusion or exclusion of column headers in delimited responses
	 */
	@Deprecated
	public void setColhead(Boolean colhead) {
		this.colhead = colhead.booleanValue();
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}.
	 * Calls {@link #setColhead(String[])}. 
	 * @since 0.4.0.0
	 * @param colHead flag for inclusion or exclusion of column headers in delimited responses
	 */
	public void setColHead(String[] colHead) {
		this.setColhead(colHead);
	}

	/** 
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param colhead flag for inclusion or exclusion of column headers in delimited responses
	 */
	public void setColhead(String[] colhead) {
		boolean b = Boolean.parseBoolean(colhead[0]); 
		if (b)
		{
			this.colhead = b;
		}
		l.debug(getFormattedDebugString("colhead", String.valueOf(this.colhead)));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setCompact(String[])}
	 * @param compact flag to indicate whether or not to return default json response with short keys
	 */
	@Deprecated
	public void setCompact(boolean compact) {
		this.compact = compact;
		l.debug(getFormattedDebugString("compact", String.valueOf(compact)));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param compact flag to indicate whether or not to return default json response with short keys
	 */
	public void setCompact(String[] compact) {
		boolean b = Boolean.parseBoolean(compact[0]); 
		if (b)
		{
			this.compact = b;
		}
		l.debug(getFormattedDebugString("compact", String.valueOf(this.compact)));
	}
	
	/**
   * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
   * @param cookies the array of cookie names to pass to the REST query
   * @since 0.5.1.0
   */
  public void setCookies(String[] cookies)
  {
    String[] lCook = cookies[0].split(PARAM_DELIMITER);
    if (lCook.length > 0)
    {
      for (String cook : lCook)
      {
        this.addCookie(cook);
      }
    }
    l.debug(getFormattedDebugString("args", lCook.toString()));
  }
	
	/**
	 * Standard mutatar for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setCount(String[])}
	 * @param count flag to indicate whether or not to execute the second query for counting results
	 */
	@Deprecated
	public void setCount(boolean count) {
		this.count = count;
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param count flag to indicate whether or not to execute the second query for counting results
	 */
	public void setCount(String[] count) {
		boolean b = Boolean.parseBoolean(count[0]); 
		if (!b)
		{
			this.count = b;
		}
		l.debug(getFormattedDebugString("count", String.valueOf(this.count)));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setCountOnly(String[])}
	 * @param countOnly flag to indicate whether or not to skip the data query and execute only the count query
	 */
	@Deprecated
	public void setCountOnly(boolean countOnly) {
		this.countOnly = countOnly;
		l.debug(getFormattedDebugString("countOnly", String.valueOf(countOnly)));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param countOnly flag to indicate whether or not to skip the data query and execute only the count query
	 */
	public void setCountOnly(String[] countOnly) {
		
		boolean b = Boolean.parseBoolean(countOnly[0]); 
		if (b)
		{
			this.countOnly = b;
		}
		l.debug(getFormattedDebugString("countOnly", String.valueOf(this.countOnly)));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param commitQuery flag to indicate whether or not to commit after each query execution, or at the end of all query executions 
	 */
	public void setCommitQuery(String[] commitQuery) {
		
		boolean b = Boolean.parseBoolean(commitQuery[0]); 
		if (!b)
		{
			this.commitQuery = b;
		}
		l.debug(getFormattedDebugString("commitQuery", String.valueOf(this.commitQuery)));
	}
	
	/** 
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setExport(String[])}
	 * @param export flag to indicate whether or not to dump results to a file and return it's url to the client
	 */
	@Deprecated
	public void setExport(boolean export) {
		this.export = export;
		l.debug(getFormattedDebugString("export", String.valueOf(export)));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param export flag to indicate whether or not to dump results to a file and return it's url to the client
	 */
	public void setExport(String[] export) {
		boolean b = Boolean.parseBoolean(export[0]); 
		if (b)
		{
			this.export = b;
		}
		l.debug(getFormattedDebugString("export", String.valueOf(this.export)));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setExportLimit(String[])}
	 * @param exportLimit maximim number of results to export
	 */
	@Deprecated
	public void setExportLimit(int exportLimit) {
		this.exportLimit = exportLimit;
		l.debug(getFormattedDebugString("exportLimit", String.valueOf(this.exportLimit)));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param exportLimit maximim number of results to export
	 */
	public void setExportLimit(String[] exportLimit) {
		int i = new Integer(exportLimit[0]).intValue();
		if (i > -1)
		{
			this.exportLimit = i;
		}
		l.debug(getFormattedDebugString("exportLimit", String.valueOf(this.exportLimit)));
	}
	
	/**
	 * Mutator for variable
	 * @deprecated As of YADA 0.4.0.0.  Use {@link #setFilters(String[])}
	 * @param filters json object conforming to filter spec
	 */
	@Deprecated
	public void setFilters(JSONObject filters) {
		this.filters = filters;
		l.debug(getFormattedDebugString("filters", this.filters.toString()));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param filters json object conforming to filter spec
	 * @throws YADARequestException when {@code filters} contains a malformed json string
	 */
	public void setFilters(String[] filters) throws YADARequestException {
		try
		{
			this.filters = new JSONObject(filters[0]);
		}
		catch(JSONException e)
		{
			throw new YADARequestException(e.getMessage(),e);
		}
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * The implementation supports passage of a JSONObject or JSONArray. See the Harmony Map Specification for details.
	 * 
	 * @since 0.4.0.0
	 * @param harmonyMap json object conforming to harmony map spec
	 * @throws YADARequestException when {@code harmonyMap} contains a malformed json string
	 */
	public void setHarmonyMap(String[] harmonyMap) throws YADARequestException {
	  //TODO convert to ArrayList and LinkedHashMaps rather than JSONArray,JSONObject to preserve ordering
		try
		{
			this.harmonyMap = new JSONArray(harmonyMap[0]); 
		}
		catch(JSONException e)
		{
		  try
		  {
  		  this.harmonyMap = new JSONArray();
  		  this.harmonyMap.put(new JSONObject(harmonyMap[0]));
		  }
		  catch(JSONException e1)
		  {
		    throw new YADARequestException(e1.getMessage(),e1);
		  }
		}
	}

	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0
	 * @param format the output type
	 */
	@Deprecated
	public void setFormat(String format) {
		this.format = format;
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * If {@code format} equals {@link #FORMAT_PIPE} or {@link #FORMAT_TSV}, then {@link #delimiter} will 
	 * be set with either {@link #FORMAT_PIPE_STRING} or {@link #FORMAT_TSV_STRING}, accordingly 
	 * @since 0.4.0.0
	 * @param format the output type
	 */
	public void setFormat(String[] format) {
		this.format = format[0];
		// reset delimiter string 
		if(this.format.equals(FORMAT_TSV) || this.format.equals(FORMAT_TAB))
			this.delimiter = FORMAT_TSV_STRING;
		else if(this.format.equals(FORMAT_PIPE) || this.format.equals(FORMAT_PSV))
			this.delimiter = FORMAT_PIPE_STRING;
		l.debug(getFormattedDebugString("format", this.format));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param delimiter the column separator for delimited output
	 */
	public void setDelimiter(String[] delimiter) {
		this.delimiter = delimiter[0];
		setFormat(new String[] { FORMAT_DELIMITED }); 
		l.debug(getFormattedDebugString("delimiter", this.delimiter));
		l.debug(getFormattedDebugString("format", this.format));
	}

	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param rowDelimiter the line separator for delimited output
	 */
	public void setRowDelimiter(String[] rowDelimiter) {
		this.rowDelimiter = rowDelimiter[0];
		l.debug(getFormattedDebugString("rowDelimiter", this.rowDelimiter));
	}

	/**
	 * Useful for plugins, rather than being forced to construct strings
	 * to pass to its overloaded twin. 
	 * 
	 * The JSONArray must be an array of JSON objects which reflects the 
	 * following format:
	 * 
	 * [
	 *   {"qname":"query name 1",
	 *    "DATA":[{"field1":"value1","field2":"value2",..."field_n":"value_n"},...
	 *            {...}]
	 *   },
	 *   {"qname":"query name 2",
	 *    "DATA":[...]
	 *   },
	 *   ...
	 * ]
	 * @deprecated as of 0.4.0.0
	 * @param ja a json array conforming to the JSONParams spec
	 * @throws YADARequestException when {@code ja} contains a malformed json string
	 */
	@Deprecated
	public void setJSONParams(JSONArray ja) throws YADARequestException {
		setJSONParams(new String[] {ja.toString()});
	}
	
	/**
	 * The JSONArray must be an array of JSON objects which reflects the 
	 * following format:
	 * 
	 * [
	 *   {"qname":"query name 1",
	 *    "DATA":[{"field1":"value1","field2":"value2",..."field_n":"value_n"},...
	 *            {...}]
	 *   },
	 *   {"qname":"query name 2",
	 *    "DATA":[...]
	 *   },
	 *   ...
	 * ]
	 * @deprecated as of 0.4.0.0
	 * @since 0.4.0.0
	 * @param JSONParams an array containing a string conforming to the JSONParams specification
	 * @throws YADARequestException  when {@code JSONParams} contains a malformed json string
	 */
	@Deprecated
	public void setJSONParams(String[] JSONParams) throws YADARequestException {
		try 
		{
			JSONArray jsonArray = new JSONArray(JSONParams[0]);
			for (int i = 0; i < jsonArray.length(); i++) // multiple queries
			{
				// object with the query and data
				JSONObject query = jsonArray.getJSONObject(i); 
				String lQname    = query.getString(JSON_KEY_QNAME); // query name 
				if (!this.JSONParams.containsKey(lQname)) 
				{
					this.JSONParams.put(lQname,
							// store the query and a structure for data
							new ArrayList>()); 
				}
				
				// multiple rows of data
				JSONArray rows = query.getJSONArray(JSON_KEY_DATA); 

				for (int j = 0; j < rows.length(); j++) 
				{
					JSONObject row = rows.getJSONObject(j); // row
					Iterator iter = row.keys();
					Map dataForRow = new HashMap<>();
					while (iter.hasNext()) 
					{
						String column = ((String) iter.next()).toUpperCase();
						String value = ""; 
						JSONArray valIsArray;
						try
						{
							valIsArray = row.getJSONArray(column);
							for (int k=0;k{"true"} to include labels
	 */
	public void setLabels(String[] labels) {
		boolean b = Boolean.parseBoolean(labels[0]); 
		if (b)
		{
			this.labels = b;
		}
		l.debug(getFormattedDebugString("labels", String.valueOf(this.labels)));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param mail the mail spec
	 */
	@Deprecated
	public void setMail(String mail) {
		this.mail = mail;
		l.debug(getFormattedDebugString("mail", mail));
	}
	
	/**
	 * @since 0.4.0.0
	 * @param mail the mail spec
	 */
	public void setMail(String[] mail) {
		this.mail = mail[0];
		l.debug(getFormattedDebugString("mail", this.mail));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param method the yada request type
	 */
	@Deprecated
	public void setMethod(String method) {
		this.method = method;
	}
	
	/**
	 * @since 0.4.0.0
	 * @param method the yada request type
	 */
	public void setMethod(String[] method) {
		this.method = method[0];
		l.debug(getFormattedDebugString("method", this.method));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param args bypass plugin arguments
	 */
	@Deprecated
	public void setOverArgs(List args) {
		this.bypassArgs = args;
		l.debug(getFormattedDebugString("bypassArgs", args.toString()));
	}
	
	/**
	 * @since 0.4.0.0
	 * @param argArr bypass plugin arguments
	 */
	public void setOverargs(String[] argArr) {
		this.setBypassargs(argArr);
	}
	
	/**
	 * @since 0.4.0.0
	 * @param argArr bypass plugin arguments
	 */
	public void setBypassargs(String[] argArr)
	{
		if (argArr.length > 0 && this.plugin == null)
		{
			setPlugin(new String[] {SCRIPT_BYPASS});
		}
		String[] lArgs = argArr[0].split(PARAM_DELIMITER);
		if (lArgs.length > 0)
		{
			for (String arg : lArgs)
			{
				this.addBypassArg(arg);
			}
		}
		l.debug(getFormattedDebugString("bypassargs", lArgs.toString()));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param pretty flag indicating whether or not to pretty print JSON results
	 */
	@Deprecated
	public void setPretty(boolean pretty) {
		this.pretty = pretty;
		l.debug(getFormattedDebugString("pretty", String.valueOf(pretty)));
	}
	
	/**
	 * @since 0.4.0.0
	 * @param protocol adaptor type
	 */
	public void setProtocol(String[] protocol) {
		this.protocol = protocol[0];
		l.debug(getFormattedDebugString("protocol", this.protocol));
	}
	
	/**
	 * @param proxy the proxy to set
	 * @since 0.4.1.0
	 */
	public void setProxy(String[] proxy)
	{
		this.proxy = proxy[0];
		l.debug(getFormattedDebugString("proxy", this.proxy));
	}

	
	/**
	 * @since 0.4.0.0
	 * @param pretty flag indicating whether or not to pretty print JSON results
	 */
	public void setPretty(String[] pretty) {
		boolean b = Boolean.parseBoolean(pretty[0]); 
		if (b)
		{
			this.pretty = b;
		}
		l.debug(getFormattedDebugString("pretty", String.valueOf(this.pretty)));
	}
	
	/**
	 * Alias for setPageStart
	 * @since 0.4.0.0
	 * @param page the subset of results
	 */
	public void setPage(String[] page) {
		this.setPageStart(page);
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param pageSize the number of result "rows" to return
	 */
	@Deprecated
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
	
	/**
	 * @since 0.4.0.0
	 * @param pageSize the number of result "rows" to return
	 */
	public void setPageSize(String[] pageSize) {
		int i = new Integer(pageSize[0]).intValue();
		if (i != YADARequest.DEFAULT_PAGE_SIZE)
		{
			if(i == -1)
			{
				this.pageSize = MAX_PAGE_SIZE;
			}
			else
			{
				this.pageSize = i;
			}
		}
		l.debug(getFormattedDebugString("pageSize", String.valueOf(this.pageSize)));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param pageStart the subset of results
	 */
	@Deprecated
	public void setPageStart(int pageStart) {
		this.pageStart = pageStart;
		l.debug(getFormattedDebugString("pageStart", String.valueOf(pageStart)));
	}
	
	/**
	 * @since 0.4.0.0
	 * @param pageStart the subset of results
	 */
	public void setPageStart(String[] pageStart) {
		int i = new Integer(pageStart[0]).intValue();
		if (i != YADARequest.DEFAULT_START_PAGE)
		{
			this.pageStart = i;
		}
		l.debug(getFormattedDebugString("pageStart", String.valueOf(this.pageStart)));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param parallel flag indicating whether or not to execute the count query in a separate thread
	 */
	@Deprecated
	public void setParallel(boolean parallel) {
		this.parallel = parallel;
		l.debug(getFormattedDebugString("parallel", String.valueOf(parallel)));
	}
	
	/**
	 * @since 0.4.0.0
	 * @param parallel flag indicating whether or not to execute the count query in a separate thread
	 * @deprecated since 0.4.0.0
	 */
	@Deprecated
	public void setParallel(String[] parallel) {
		boolean b = Boolean.parseBoolean(parallel[0]); 
		if (b)
		{
			this.parallel = b;
		}
		
		l.debug(getFormattedDebugString("parallel", String.valueOf(parallel)));
	}
	
	/**
	 * @since 0.1.0.0
	 * @param params list of data values to plug into query parameters
	 */
	public void setParams(String[] params) {
		char[] p = params[0].toCharArray(); // the values passed in
		List paramList = new ArrayList<>();
		StringBuffer param     = new StringBuffer(), 
								 array     = null;
		for(int i=0;i 0)
			{
			  // add the current param to the list
				paramList.add(new String[] {param.toString()});
				// reset the param to null
				param = new StringBuffer();
			}
			// in the array
			else if(array != null)
			{
				// add the char to the stringbuffer
				array.append(c);
			}
			else if(c != ',')
			{
				// add the char to the stringbuffer
				param.append(c);
				// if end of param string
				if(i == p.length-1)
				{
					// add the current param to the list
					paramList.add(new String[] {param.toString()});
				}
			}
		}
		this.params = new String[paramList.size()][];
		for (int j = 0; j < paramList.size(); j++)
		{
			this.params[j] = paramList.get(j);
		}
//		Pattern ARRAY_RX = Pattern.compile("([^\\[\\]],[^\\[\\]]+)+"); // this pattern matches the contents inside brackets	
		l.debug(getFormattedDebugString("params", Arrays.toString(params)));
	}
	
	/**
	 * @since PROVISIONAL
	 * @param paramset a stored set of parameters
	 */
	public void setParamset(String[] paramset) {
		l.debug(paramset[0]);
		this.paramset = paramset[0];
		l.debug(getFormattedDebugString("paramset", this.paramset));
	}
	
	/** 
	 * Sets the class name or fully-qualified class name of the plugin.
	 * @deprecated As of YADA 0.4.0.0
	 * @param plugin the class name or fully-qualified class name of the plugin
	 */
	@Deprecated
	public void setPlugin(String plugin) {
		setPlugin(new String[] {plugin});
	}
	
	/**
	 * Sets the class name or fully-qualified class name of the plugin.  The plugin type is auto-detected.
	 * @since 0.4.0.0
	 * @param plugin the class name or fully-qualified class name of the plugin
	 */
	public void setPlugin(String[] plugin) {
		// only 1 plugin param, and a comma delimted string, rather than multiple params
		if (plugin.length == 1 && plugin[0].indexOf(PARAM_DELIMITER)>-1)
		{
			this.plugin = plugin[0].split(PARAM_DELIMITER);
		}
		else
		{
			this.plugin = plugin;
		}
		l.debug(getFormattedDebugString("plugin", plugin));
	}
	
	/**
	 * Sets the class name or fully-qualified class name of the response.  The default is 
	 * determined dynamically from the value of {@code format}
	 * @since 0.4.0.0
	 * @param response the class name or fully-qualified class name of the response
	 */
	public void setResponse(String[] response) {
		l.debug(response[0]);
		this.response = response[0];
		l.debug(getFormattedDebugString("response", response));
	}
	
	/**
	 * Sets the class name or fully-qualified class name of the converter.  The default is 
	 * determined dynamically from the value of {@code format} and {@code protocol}.
	 * @since 0.4.0.0
	 * @param converter the class name or fully-qualified class name of the converter
	 */
	public void setConverter(String[] converter) {
		l.debug(converter[0]);
		this.converter = converter[0];
		l.debug(getFormattedDebugString("converter", converter));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param pluginType the type of the plugin, i.e., preprocessor, postprocessor, or bypass
	 */
	@Deprecated
	public void setPluginType(String pluginType) {
		setPluginType(new String[] {pluginType});
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @since 0.4.0.0
	 * @param pluginType the type of the plugin, i.e., preprocessor, postprocessor, or bypass
	 */
	@Deprecated
	public void setPluginType(String[] pluginType) {
		// only 1 plugin param, and a comma delimted string, rather than multiple params
		if (pluginType.length == 1 && pluginType[0].indexOf(PARAM_DELIMITER)>-1)
		{
			this.pluginType = pluginType[0].split(PARAM_DELIMITER);
		}
		else
		{
			this.pluginType = pluginType;
		}
		l.debug(getFormattedDebugString("pluginType", pluginType));
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @param postArgs the args to pass to the post processor plugin
	 */
	@Deprecated
	public void setPostArgs(List postArgs)
	{
		setPostArgs((String[])postArgs.toArray());
	}
	
	/**
	 * @since 0.4.0.0
	 * @param postArgArr the args to pass to the post processor plugin
	 */
	public void setPostArgs(String[] postArgArr)
	{
		if (postArgArr.length > 0 && this.plugin == null)
		{
			setPlugin(new String[] {SCRIPT_POSTPROCESSOR});
		}

		String[] lArgs = postArgArr[0].split(PARAM_DELIMITER);
		if (lArgs.length > 0)
		{
			for (String arg : lArgs)
			{
				this.addPostArg(arg);
			}
		}
		l.debug(getFormattedDebugString("postargs", lArgs.toString()));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @param postArgArr list of arguments to pass to the post processor plugin
	 */
	public void setPostargs(String[] postArgArr)
	{
		this.setPostArgs(postArgArr);
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setPreargs(String[])}
	 * @param preArgs list of arguments to pass to the preprocessor
	 */
	@Deprecated
	public void setPreArgs(List preArgs) {
		this.preArgs = preArgs;
		l.debug(getFormattedDebugString("preArgs", preArgs.toString()));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @param preArgArr list of arguments to pass to the preprocessor 
	 * @since 0.4.0.0
	 */
	public void setPreargs(String[] preArgArr) {
		this.setPreArgs(preArgArr);
	}
	
	/** 
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @param preArgArr list of arguments to pass to the preprocessor
	 * @since 0.4.0.0
	 */
	public void setPreArgs(String[] preArgArr)
	{
		if (preArgArr.length > 0 && this.getPlugin() == null)
		{
			this.setPlugin(new String[] {SCRIPT_PREPROCESSOR});
		}
		String[] lArgs = preArgArr[0].split(PARAM_DELIMITER);
		if (lArgs.length > 0)
		{
			for (String arg : lArgs)
			{
				this.addPreArg(arg);
			}
		}
		l.debug(getFormattedDebugString("preargs", lArgs.toString()));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0
	 * @param qname the query name
	 */
	@Deprecated
	public void setQname(String qname) {
		this.qname = qname;
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param qname the query name
	 */
	public void setQname(String[] qname) {
		l.debug(qname[0]);
		this.qname = qname[0];
		l.debug(getFormattedDebugString("qname", this.qname));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setSortKey(String[])}.
	 * @param sortKey c
	 */
	@Deprecated
	public void setSortKey(String sortKey) {
		this.sortKey = sortKey;
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param sortKey the column on which to sort
	 */
	public void setSortKey(String[] sortKey) {
		this.sortKey = sortKey[0];
		l.debug(getFormattedDebugString("sortKey", this.sortKey));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0. Use {@link #setSortOrder(String[])}
	 * @param sortOrder the sort order, defaults to {@link #SORT_ASC}
	 */
	@Deprecated
	public void setSortOrder(String sortOrder) {
		this.sortOrder = sortOrder; 
	}

	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param sortOrder the sort order, defaults to {@link #SORT_ASC}
	 */
	public void setSortOrder(String[] sortOrder) {
		this.sortOrder = sortOrder[0];
		l.debug(getFormattedDebugString("sortOrder", this.sortOrder));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @param updateStats flag indicating whether or not to execute the query access statistics when the query is included in a request
	 * @since 0.4.0.0
	 */
	public void setUpdateStats(String[] updateStats) {
		boolean b = Boolean.parseBoolean(updateStats[0]); 
		if (!b)
		{
			this.updateStats = b;
		}
		l.debug(getFormattedDebugString("updateStats", String.valueOf(this.updateStats)));
	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0
	 * @param user the user id passed in the request, defaults to {@link #DEFAULT_USER} 
	 */
	@Deprecated
	public void setUser(String user) {
		this.user = user;
	}

	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param user the user id passed in the request, defaults to {@link #DEFAULT_USER}
	 */
	public void setUser(String[] user) {
		this.user = user[0];
		l.debug(getFormattedDebugString("user", this.user));
	}
	
//	/**
//	 * @since 0.4.0.0
//	 */
//	public void setAuthUser(String[] authUser) {
//		this.authUser = authUser[0];
//	}
	
	/**
	 * Standard mutator for variable
	 * @deprecated As of YADA 0.4.0.0
	 * @param viewLimit the maximum number of rows to retrieve, independent of {@code pageSize}
	 */
	@Deprecated
	public void setViewLimit(int viewLimit) {
		this.viewLimit = viewLimit;
		l.debug(getFormattedDebugString("viewLimit", String.valueOf(this.viewLimit)));
	}
	
	/**
	 * Array mutator for variable, preferred for compatibility with {@link javax.servlet.http.HttpServletRequest#getParameterMap()}
	 * @since 0.4.0.0
	 * @param viewLimit the maximum number of rows to retrieve, independent of {@code pageSize}
	 */
	public void setViewLimit(String[] viewLimit) {
		int i = new Integer(viewLimit[0]).intValue();
		if (i > -1)
		{
			this.viewLimit = i;
		}
		l.debug(getFormattedDebugString("viewLimit", String.valueOf(this.viewLimit)));
	}
	
	
	/**
	 * Standard accessor for variable
	 * @return the list containing the plugin args
	 */
	public List getArgs() {
		return this.args;
	}
	
	/**
   * Standard accessor for variable
   * @return the list containing the cookie names
   * @since 0.5.1.0
   */
  public List getCookies() {
    return this.cookies;
  }
	
	/**
	 * Standard accessor for variable
	 * @return boolean value of {@code colhead}
	 */
	public boolean getColHead() {
		return this.colhead;
	}
	
	/**
	 * Standard accessor for variable.  If {code true} (the default
	 * @return boolean value of {@code colhead}
	 */
	public boolean getColhead() {
		return this.colhead;
	}
	
	/**
	 * Standard accessor for variable.  The {@code compact} parameter is currently unimplemented.
	 * @return boolean value of {@code compact}
	 */
	public boolean getCompact() {
		return this.compact;
	}
	
	/**
	 * Standard accessor for variable.  If {@code true}, and the query protocol is {@link Parser#JDBC},
	 * the core code is wrapped in a {@code SELECT COUNT(*)} query, 
	 * which is added to the request in the processing phase, to return the total result count of the query.  
	 * This is particularly useful when executing the query from a GUI client which uses pagination.  
	 * IF set to {@code false}, only the original query is  executed. For more details see the Users' Guide
	 * If the query protocol is {@link Parser#REST} or {@link Parser#SOAP}, {@code count} is automatically set to {@code false}. 
	 * @return boolean value of {@code count}
	 */
	public boolean getCount() {
		return this.count;
	}
	
	/**
	 * Standard accessor for variable. If {@code true}, and the query protocol is {@link Parser#JDBC}, 
	 * the core code is wrapped in a {@code SELECT COUNT(*)} query, and 
	 * only this query is executed in the processing phase. Only the record count is returned.  No data is returned. 
	 * If the query protocol is {@link Parser#REST} or {@link Parser#SOAP}, {@code countOnly} is ignored.
	 * For more details see the Users' Guide
	 * @return boolean value of {@code countOnly}
	 */
	public boolean getCountOnly() {
		return this.countOnly;
	}
	
	/**
	 * Standard accessor for variable. If {@code true}, the results are automatically formatted as {@link #FORMAT_CSV}
	 * and written to a file.  The url of the file is then returned to facilitate retrieval of the file.
	 *
	 * @return boolean value of {@code export}
	 */
	public boolean getExport() {
		return this.export;
	}
	
	/**
	 * @return maximum number of rows to export
	 */
	public int getExportLimit() {
		return this.exportLimit;
	}
	
	/**
	 * Returns the {@code filter} or {@code fi} parameter value as a {@link JSONObject}
	 * @return a {@link JSONObject} built from the {@code filter} or {@code fi} parameter value
	 */
	public JSONObject getFilters() {
		return this.filters;
	}
	
	/**
	 * Returns the value of the {@code format} or {@code f} parameter, a value equal to one of the following:
	 * 
	 * {@link #FORMAT_CSV}
	 * {@link #FORMAT_TSV}
	 * {@link #FORMAT_PIPE}
	 * {@link #FORMAT_JSON} (the default)
	 * {@link #FORMAT_XML}
	 * {@link #FORMAT_HTML} (useful as a tool for query authoring)
	 * 
	 * @return the desired result format
	 */
	public String getFormat() {
		return this.format;
	}
	
	/**
	 * Returns the value of the column delimiter used by delimited result formats.  The default is comma.
	 * @return the string value of the column delimiter, defaults to comma
	 */
	public String getDelimiter() {
		return this.delimiter;
	}
	
	/**
	 * Returns the {@code harmonyMap} or {@code h} parameter value as a {@link JSONObject}
	 * @return a {@link JSONArray} built from the value of the {@code harmonyMap} or {@code h} parameter value
	 */
	public JSONArray getHarmonyMap() {
		return this.harmonyMap;
	}
	
	/**
	 * Standard accessor for variable, a newline by default.
	 * @return the character string for delimiting rows in the response
	 */
	public String getRowDelimiter() {
		return this.rowDelimiter;
	}
	
	/**
	 * Standard accessor for variable. If {@code true}, YADA will execute a commit after each all rows in each query 
	 * have been processed. When {@code false}, as is the default, YADA will execute a commit on each connection after
	 * all queries have been executed. 
	 * @return a boolean indicating whether to commit transactions after each query, or at the end of the request.
	 */
	public boolean getCommitQuery() {
		return this.commitQuery;
	}
	
	/**
	 * Returns the old internal {@code JSONParams} object.  This object should no longer be used.
	 * @deprecated as of 0.4.0.0
	 * @return {@link java.util.Map}<{@link String}, {@link java.util.List}<{@link java.util.Map}<{@link String},{@link String}>>>
	 */
	@Deprecated
	public Map>> getJSONParams() {
		return this.JSONParams;
	}
	
	/**
	 * Returns the internal {@code jsonParams} object.
	 * @since 0.4.0.0
	 * @return {@link JSONParams}
	 */
	public JSONParams getJsonParams() {
		return this.jsonParams;
	}
	
	/**
	 * This is currently unsupported.
	 * @return the labels
	 */
	public boolean getLabels() {
		return this.labels;
	}
	
	/**
	 * Retuns the mail spec used by the builtin {@link EmailBypassPlugin}
	 * @return the mail specification, used by the builtin {@link EmailBypassPlugin}
	 */
	public String getMail() {
		return this.mail;
	}

	/**
	 * Returns the value of the {@code method} or {@code m} parameter: either {@link #METHOD_GET}, {@link #METHOD_UPDATE},
	 * or {@link #METHOD_UPLOAD}.
	 * @return the value of the {@code method} or {@code m} parameter
	 */
	public String getMethod() {
		return this.method;
	}
	
	/**
	 * Returns the list of arguments to be passed to the Bypass plugin
	 * @return list of arguments to pass to the Bypass plugin
	 * @see Bypass
	 */
	public List getBypassArgs() {
		return this.bypassArgs;
	}
	
	/**
	 * Returns the number of rows to return from the current set of request. 
	 * Note: there are a number of possible permutations of results, particularly when multiple queries are
	 * submitted in a single request.  Currently YADA only returns the first {@code pageSize} rows. See YADA Parameters Reference
	 * for more details.  
	 * @return the number of rows to return from the current request
	 */
	public int getPageSize() {
		return this.pageSize;
	}
	
	
	/**
	 * Returns the results from page {@code pageStart}, using {@link #getPageSize()} to determine which row should
	 * be the first row.  This is a common pagination implementation--nothing fancy here.  For example, if {@code pageSize} is 
	 * {@code 20}, and {@code pageStart} is {@code 3}, then the results returned would be rows 41-60.
	 * @return the first, or current, page of results to return
	 */
	public int getPageStart() {
		return this.pageStart;
	}
	
	/**
	 * Returns a {@code boolean} value corresponding to the {@code parallel} url parameter
	 * @deprecated as of 0.4.0.0
	 * @return true if url parameter {@code parallel} was set to true, otherwise false 
	 */
	@Deprecated
	public boolean getParallel() {
		return this.parallel;
	}
	
	/**
	 * {@code params} is an array of arrays to support the json-derived array syntax 
	 * in a list of param values, e.g., {@code p=val1,[val_a,val_b,val_c],val3}
	 * @return the array of param arrays
	 */
	public String[][] getParams() {
		return this.params;
	}
	
	/**
	 * This is currently unsupported.
	 * @return a parameter set
	 */
	public String getParamset() {
		return this.paramset;
	}
	
	/**
	 * 
	 * @return the plugin class name
	 */
	public String[] getPlugin() {
		return this.plugin;
	}
	
	/**
	 * @deprecated As of YADA 0.4.0.0
	 * @return {@link String}[] array of {@code pluginType} parameter values
	 */
	@Deprecated
	public String[] getPluginType() {
		return this.pluginType;
	}
	
	/**
	 * Returns the list of arguments passed to the {@link Postprocess} plugin
	 * @return list of arguments passed to the {@link Postprocess} plugin
	 */
	public List getPostArgs() {
		return this.postArgs;
	}
	
	/**
	 * Returns the list of arguments passed to the {@link Preprocess} plugin
	 * @return list of arguments passed to the {@link Preprocess} plugin
	 */
	public List getPreArgs() {
		return this.preArgs;
	}

	/**
	 * If {@code true}, json-formatted results should return with proper indentation and line feeds.
	 * @return boolean value indicating whether or not to pretty print json output (i.e., indent)
	 */
	public boolean getPretty() {
		return this.pretty;
	}
	
	/**
	 * Returns the value of the {@code protocol} variable, as set in {@link QueryManager}.  Value will be one of:
	 * {@link Parser#JDBC}, {@link Parser#SOAP}, {@link Parser#REST}, or {@link Parser#FILE}
	 * @return the value of {@code protocol}
	 */
	public String getProtocol() {
		return this.protocol;
	}
	
	/**
	 * Returns the value of the proxy server to use for external REST queries
	 * @return the proxy
	 */
	public String getProxy()
	{
		return this.proxy;
	}
	
	/**
	 * Returns the current query name.  This value defaults to {@code YADA dummy}. 
	 * If the url contains the {@code qname} or {@code q}
	 * parameter and the default value, the request will only be processed if the url query string 
	 * also contains a {@code plugin} parameter referencing a {@link #BYPASS} or {@link #PREPROCESS} plugin.
	 * 
	 * @return the query name
	 */
	public String getQname() {
		return this.qname;
	}
	
	/**
	 * Returns the name of the the {@link com.novartis.opensource.yada.format.Response} implementation class. The default response is
	 * determined dynamically based on the value of {@code format}.
	 * @return the name of the {@link com.novartis.opensource.yada.format.Response} class
	 */
	public String getResponse() {
		return this.response;
	}
	
	/**
	 * Returns the name of the the {@link com.novartis.opensource.yada.format.Converter} implementation class. The default converter is
	 * determined dynamically based on the value of {@code format} and {@code protocol}.
	 * 
	 * @return the name of the {@link com.novartis.opensource.yada.format.Converter} class
	 */
	public String getConverter() {
		return this.converter;
	}
	
	/**
	 * Standard accessor for variable.
	 * @return the value of the parameter
	 */
	public String getSortKey() {
		return this.sortKey;
	}

	/**
	 * Standard accessor for variable. Default is {@link #SORT_ASC}.
	 * @return the value of the parameter
	 */
	public String getSortOrder() {
		return this.sortOrder;
	}
	/**
	 * Standard accessor for variable.  If {@code true}, the default, the {@link Finder} will execute a
	 * parallel operation to increment the query access count value and the last accessed date in the YADA index. 
	 * IF set to {@code false}, the parallel operation is skipped.
	 * @return boolean value of {@code count}
	 * @since 0.5.0.0
	 */
	public boolean getUpdateStats() {
		return this.updateStats;
	}
	/**
	 * Standard accessor for variable. Default is {@link #DEFAULT_USER}
	 * @return the value of the parameter
	 */
	public String getUser() {
		return this.user;
	}
	
	/**
	 * {@code viewLimit} is a performance related parameter which truncates a query result at {@code viewLimit} rows.
	 * In other words it is a "maximum number of rows" setting. It is useful in GUI client applications which enable 
	 * filtering of very large result sets, but also enable browsing of entire data sets.  
	 * @return the value of the parameter
	 */
	public int getViewLimit() {
		return this.viewLimit;
	}

	/**
   * @return the join specification
   * @since 0.6.2.0
   * @see #setJoin(String[])
   */
  public String getJoin() {
    return this.join;
  }

  /**
   * Set to {@code true} to join on any matching keys in across queries.
   * Set to a comma-separated list of keys to join only on matching values of those keys.
   * When {@link #harmonyMap} accompanies this param, the target keys are used
   * @param join the join spec, either {@code true} or a comma-separated list of keys
   * @since 0.6.2.0
   */
  public void setJoin(String[] join) {
    this.join = join[0];
  }

  /**
   * @return the leftjoin specification
   * @since 0.6.2.0
   * @see #setLeftjoin(String[])
   */
  public String getLeftJoin() {
    return this.leftJoin;
  }

  /**
   * Set to {@code true} to left join on any matching keys across queries.
   * Set to a comma-separated list of keys to join only on matching values of those keys.
   * When {@link #harmonyMap} accompanies this param, the target keys are used
   * @param leftjoin leftjoin spec, either {@code true} or a comma-separated list of keys
   * @since 0.6.2.0
   */
  public void setLeftJoin(String[] leftjoin) {
    this.leftJoin = leftjoin[0];
  }

  /** 
	 * @since 0.4.0.0
	 */
	public void resetJsonParams() {
		this.jsonParams = new JSONParams();
	}
	
	
	/**
	 * @deprecated as of 0.4.0.0
	 */
	@Deprecated
	public void resetJSONParams() {
		this.JSONParams = new LinkedHashMap<>();
	}
	
	/**
	 * Sets the upload items which will then be dervied from the
	 * YADARequest by the preprocessor plugin
	 * 
	 * @param uploadItems list of form field name/value pairs and upload content
	 * @throws YADARequestException when a method invocation problem occurs while setting parameter values
	 */
	public void setUploadItems(List uploadItems) throws YADARequestException 
	{
		this.uploadItems = uploadItems;
		Iterator iter = uploadItems.iterator();
		while (iter.hasNext()) {
			DiskFileItem fi = (DiskFileItem) iter.next();
			l.debug(fi);
			// String output = "";
			// set parameters from form fields
			if (fi.isFormField()) 
			{
				String field = fi.getFieldName();
				String value = fi.getString();
				l.debug("field is ["+field+"], value is ["+value+"]");
				invokeSetter(field,new String[] {value});
				addToMap(field, new String[] {value});
			} 
			else 
			{
				File f;
				String fPath;
				String fName;
				try 
				{
					// execute plugin, as we are not calling a WS
					f = fi.getStoreLocation(); // tmp dir
					fPath = f.getAbsolutePath(); // uploaded file
					fName = fi.getName(); // original file name
				} 
				finally 
				{
					f = null;
				}
				addArg(fPath);
				addArg(fName);
			}
		}
		l.debug(getFormattedDebugString("uploadItems", uploadItems.toString()));
	}

	
	/**
	 * Returns a list of form field values and content items from the form submission when processing an uploads
	 * @return list of form fields and content items
	 */
	public List getUploadItems() {
		return this.uploadItems;
	}

	/**
	 * Takes all parameters and values from {@code paraMap}, typically set in the {@link javax.servlet.http.HttpServletRequest}, and 
	 * adds them to a local {@link java.util.Map}.  This is called by {@link Service#handleRequest(HttpServletRequest)}.
	 * The inclusion of the map enables the use of otherwise unsupported url parameters in plugins. 
	 * @param paraMap the parameter map originally set in the request
	 * @see Service#handleRequest(String, Map)
	 */
	public void setParameterMap(Map paraMap) {
		this.getParameterMap().putAll(paraMap);
		l.debug(getFormattedDebugString("parameterMap", paraMap.toString()));
	}

	/**
	 * Returns the {@link java.util.Map} of parameters originally set in the {@link javax.servlet.http.HttpServletRequest}.
	 * @return the map of parameters derived from the request
	 */
	public Map getParameterMap() {
		return this.parameterMap;
	}
	
	/**
	 * Returns {@code true} if format is {@link #FORMAT_JSON}, {@link #FORMAT_HTML}, or {@link #FORMAT_XML}, otherwise {@code false}.
	 * @since 0.4.0.0
	 * @return true if format is JSON, XML, or HTML, otherwise false
	 */
	public boolean isFormatStructured()
	{
		if(this.getFormat().equals(FORMAT_JSON) || this.getFormat().equals(FORMAT_XML) || this.getFormat().equals(FORMAT_HTML))
			return true;
		return false;
	}
	
	/**
	 * Returns {@code true} if request contains "h" or "harmonize" parameter with a value other than an empty string or null
	 * @since 0.4.0.0
	 * @return true if request contains "h" or "harmonize" parameter with a value other than an empty string or null
	 */
	public boolean hasHarmonyMap()
	{
		if(null == getHarmonyMap() || "".equals(getHarmonyMap()))
			return false;
		return true;
	}
	
	/**
	 * Returns {@code true} if {@link #cookies} contains a cookie name, otherwise {@code false}
	 * @return {@code true} if {@link #cookies} contains a cookie name, otherwise {@code false}
	 * @since 0.5.1.0
	 */
	public boolean hasCookies() {
	  if(null == this.getCookies() || this.getCookies().size() == 0)
	  {
	    return false;
	  }
	  return true;
	}

	/**
	 * A utility method for pretty-printing debug info in the form like:
	 * 
	 * {@code Set [name] to [val]}
	 * 
	 * @param name a parameter name
	 * @param val the parameter value
	 * @return a formatted string
	 */
	public String getFormattedDebugString(String name, String val) {
		String sSet = "Set [" + name + "]";
		String sVal = "["+val+"]";
		return String.format("%25s to %s", sSet, sVal);
	}
	
	/**
	 * A utility method for pretty-printing debug info in the form like:
	 * 
	 * {@code Set [name] to [string,string...]}
	 * 
	 * @param name a parameter name
	 * @param strings the parameter value
	 * @return a formatted string
	 */
	@SuppressWarnings("static-method")
	private String getFormattedDebugString(String name, String[] strings) {
		String sSet = "Set [" + name + "]";
		String sVal = "[" + ArrayUtils.toString(strings) + "]";
		return String.format("%25s to %s", sSet, sVal);
	}
}