public Parameters() 
{
        super( INITIAL_SIZE );
}

 public  void addParameterValues(String key,
    String[] newValues) 
{
        if ( key==null ) return;
        String values[];
        if (paramHashStringArray.containsKey(key)) {
            String oldValues[] = (String[])paramHashStringArray.get(key);
            values = new String[oldValues.length + newValues.length];
            for (int i = 0; i <  oldValues.length; i++) {
                values[i] = oldValues[i];
            }
            for (int i = 0; i <  newValues.length; i++) {
                values[i+ oldValues.length] = newValues[i];
            }
        } else {
            values = newValues;
        }
        paramHashStringArray.put(key, values);
}

 public Parameters getCurrentSet() 
{
        if( currentChild==null )
            return this;
        return currentChild;
}

 public String getParameter(String name) 
{
        String[] values = getParameterValues(name);
        if (values != null) {
            if( values.length==0 ) return "";
            return values[0];
        } else {
            return null;
        }
}

 public Enumeration getParameterNames() 
{
        handleQueryParameters();
        // Slow - the original code
        if( currentChild!=null ) {
            currentChild.merge();
            return currentChild.paramHashStringArray.keys();
        }
        // merge in child
        return paramHashStringArray.keys();
}

 public String[] getParameterValues(String name) 
{
        handleQueryParameters();
        // sub-request
        if( currentChild!=null ) {
            currentChild.merge();
            return (String[])currentChild.paramHashStringArray.get(name);
        }
        // no "facade"
        String values[]=(String[])paramHashStringArray.get(name);
        return values;
}

 public  void handleQueryParameters() 
{
        if( didQueryParameters ) return;
        didQueryParameters=true;
        if( queryMB==null || queryMB.isNull() )
            return;
        if( debug  > 0  )
            log( "Decoding query " + decodedQuery + " " + queryStringEncoding);
        try {
            decodedQuery.duplicate( queryMB );
        } catch (IOException e) {
            // Can't happen, as decodedQuery can't overflow
            e.printStackTrace();
        }
        processParameters( decodedQuery, queryStringEncoding );
}

Process the query string into parameters

 public String paramsAsString() 
{
        StringBuffer sb=new StringBuffer();
        Enumeration en= paramHashStringArray.keys();
        while( en.hasMoreElements() ) {
            String k=(String)en.nextElement();
            sb.append( k ).append("=");
            String v[]=(String[])paramHashStringArray.get( k );
            for( int i=0; i< v.length; i++ )
                sb.append( v[i] ).append(",");
            sb.append("\n");
        }
        return sb.toString();
}

Debug purpose

 public  void pop() 
{
        if( currentChild==null ) {
            throw new RuntimeException( "Attempt to pop without a push" );
        }
        currentChild.recycle();
        currentChild=currentChild.parent;
        // don't remove the top.
}

Discard the last child. This happens when we return from a sub-request and the parameters are locally modified.

 public  void processParameters(MessageBytes data) 
{
        processParameters(data, encoding);
}

 public  void processParameters(String str) 
{
        int end=str.length();
        int pos=0;
        if( debug  > 0)
            log("String: " + str );
        do {
            boolean noEq=false;
            int valStart=-1;
            int valEnd=-1;
            int nameStart=pos;
            int nameEnd=str.indexOf('=', nameStart );
            int nameEnd2=str.indexOf('&', nameStart );
            if( nameEnd2== -1 ) nameEnd2=end;
            if( (nameEnd2!=-1 ) &&
                ( nameEnd==-1 || nameEnd  > nameEnd2) ) {
                nameEnd=nameEnd2;
                noEq=true;
                valStart=nameEnd;
                valEnd=nameEnd;
                if( debug >0) log("no equal " + nameStart + " " + nameEnd + " " + str.substring(nameStart, nameEnd) );
            }
            if( nameEnd== -1 ) nameEnd=end;
            if( ! noEq ) {
                valStart=nameEnd+1;
                valEnd=str.indexOf('&', valStart);
                if( valEnd== -1 ) valEnd = (valStart <  end) ? end : valStart;
            }
            pos=valEnd+1;
            if( nameEnd< =nameStart ) {
                continue;
            }
            if( debug >0)
                log( "XXX " + nameStart + " " + nameEnd + " "
                     + valStart + " " + valEnd );
            try {
                tmpNameC.append(str, nameStart, nameEnd-nameStart );
                tmpValueC.append(str, valStart, valEnd-valStart );
                if( debug  > 0 )
                    log( tmpNameC + "= " + tmpValueC);
                if( urlDec==null ) {
                    urlDec=new UDecoder();   
                }
                urlDec.convert( tmpNameC );
                urlDec.convert( tmpValueC );
                if( debug  > 0 )
                    log( tmpNameC + "= " + tmpValueC);
                addParam( tmpNameC.toString(), tmpValueC.toString() );
            } catch( IOException ex ) {
                ex.printStackTrace();
            }
            tmpNameC.recycle();
            tmpValueC.recycle();
        } while( pos< end );
}

Used by RequestDispatcher

 public  void processParameters(MessageBytes data,
    String encoding) 
{
        if( data==null || data.isNull() || data.getLength() < = 0 ) return;
        if( data.getType() == MessageBytes.T_BYTES ) {
            ByteChunk bc=data.getByteChunk();
            processParameters( bc.getBytes(), bc.getOffset(),
                               bc.getLength(), encoding);
        } else {
            if (data.getType()!= MessageBytes.T_CHARS ) 
                data.toChars();
            CharChunk cc=data.getCharChunk();
            processParameters( cc.getChars(), cc.getOffset(),
                               cc.getLength());
        }
}

 public  void processParameters(byte[] bytes,
    int start,
    int len) 
{
        processParameters(bytes, start, len, encoding);
}

 public  void processParameters(char[] chars,
    int start,
    int len) 
{
        int end=start+len;
        int pos=start;
        if( debug >0 ) 
            log( "Chars: " + new String( chars, start, len ));
        do {
            boolean noEq=false;
            int nameStart=pos;
            int valStart=-1;
            int valEnd=-1;
            int nameEnd=CharChunk.indexOf(chars, nameStart, end, '=' );
            int nameEnd2=CharChunk.indexOf(chars, nameStart, end, '&' );
            if( (nameEnd2!=-1 ) &&
                ( nameEnd==-1 || nameEnd  > nameEnd2) ) {
                nameEnd=nameEnd2;
                noEq=true;
                valStart=nameEnd;
                valEnd=nameEnd;
                if( debug >0) log("no equal " + nameStart + " " + nameEnd + " " + new String(chars, nameStart, nameEnd-nameStart) );
            }
            if( nameEnd== -1 ) nameEnd=end;
            if( ! noEq ) {
                valStart= (nameEnd <  end) ? nameEnd+1 : end;
                valEnd=CharChunk.indexOf(chars, valStart, end, '&');
                if( valEnd== -1 ) valEnd = (valStart <  end) ? end : valStart;
            }
            pos=valEnd+1;
            if( nameEnd< =nameStart ) {
                continue;
                // invalid chunk - no name, it's better to ignore
                // XXX log it ?
            }
            try {
                tmpNameC.append( chars, nameStart, nameEnd-nameStart );
                tmpValueC.append( chars, valStart, valEnd-valStart );
                if( debug  > 0 )
                    log( tmpNameC + "= " + tmpValueC);
                if( urlDec==null ) {
                    urlDec=new UDecoder();   
                }
                urlDec.convert( tmpNameC );
                urlDec.convert( tmpValueC );
                if( debug  > 0 )
                    log( tmpNameC + "= " + tmpValueC);
                addParam( tmpNameC.toString(), tmpValueC.toString() );
            } catch( IOException ex ) {
                ex.printStackTrace();
            }
            tmpNameC.recycle();
            tmpValueC.recycle();
        } while( pos< end );
}

 public  void processParameters(byte[] bytes,
    int start,
    int len,
    String enc) 
{
        int end=start+len;
        int pos=start;
        if(log.isDebugEnabled()) {
            try {
                log.debug("Bytes: " +
                        new String(bytes, start, len, DEFAULT_ENCODING));
            } catch (UnsupportedEncodingException e) {
                // Should never happen...
                log.error("Unable to convert bytes", e);
            }
        }
        do {
            boolean noEq=false;
            int valStart=-1;
            int valEnd=-1;
            int nameStart=pos;
            int nameEnd=ByteChunk.indexOf(bytes, nameStart, end, '=' );
            // Workaround for a&b&c encoding
            int nameEnd2=ByteChunk.indexOf(bytes, nameStart, end, '&' );
            if( (nameEnd2!=-1 ) &&
                ( nameEnd==-1 || nameEnd  > nameEnd2) ) {
                nameEnd=nameEnd2;
                noEq=true;
                valStart=nameEnd;
                valEnd=nameEnd;
                if(log.isDebugEnabled()) {
                    try {
                        log.debug("no equal " + nameStart + " " + nameEnd + " " +
                                new String(bytes, nameStart, nameEnd-nameStart,
                                        DEFAULT_ENCODING) );
                    } catch (UnsupportedEncodingException e) {
                        // Should never happen...
                        log.error("Unable to convert bytes", e);
                    }
                }
            }
            if( nameEnd== -1 ) 
                nameEnd=end;
            if( ! noEq ) {
                valStart= (nameEnd <  end) ? nameEnd+1 : end;
                valEnd=ByteChunk.indexOf(bytes, valStart, end, '&');
                if( valEnd== -1 ) valEnd = (valStart <  end) ? end : valStart;
            }
            pos=valEnd+1;
            if( nameEnd< =nameStart ) {
                StringBuilder msg = new StringBuilder("Parameters: Invalid chunk ");
                // No name eg ...&=xx&... will trigger this
                if (valEnd  >= nameStart) {
                    msg.append('\'');
                    try {
                        msg.append(new String(bytes, nameStart,
                                valEnd - nameStart, DEFAULT_ENCODING));
                    } catch (UnsupportedEncodingException e) {
                        // Should never happen...
                        log.error("Unable to convert bytes", e);
                    }
                    msg.append("' ");
                }
                msg.append("ignored.");
                log.warn(msg);
                continue;
                // invalid chunk - it's better to ignore
            }
            tmpName.setBytes( bytes, nameStart, nameEnd-nameStart );
            tmpValue.setBytes( bytes, valStart, valEnd-valStart );
            // Take copies as if anything goes wrong originals will be
            // corrupted. This means original values can be logged.
            // For performance - only done for debug
            if (log.isDebugEnabled()) {
                try {
                    origName.append(bytes, nameStart, nameEnd-nameStart);
                    origValue.append(bytes, valStart, valEnd-valStart);
                } catch (IOException ioe) {
                    // Should never happen...
                    log.error("Error copying parameters", ioe);
                }
            }
            try {
                addParam( urlDecode(tmpName, enc), urlDecode(tmpValue, enc) );
            } catch (IOException e) {
                StringBuilder msg =
                    new StringBuilder("Parameters: Character decoding failed.");
                msg.append(" Parameter '");
                if (log.isDebugEnabled()) {
                    msg.append(origName.toString());
                    msg.append("' with value '");
                    msg.append(origValue.toString());
                    msg.append("' has been ignored.");
                    log.debug(msg, e);
                } else {
                    msg.append(tmpName.toString());
                    msg.append("' with value '");
                    msg.append(tmpValue.toString());
                    msg.append("' has been ignored. Note that the name and ");
                    msg.append("value quoted here may corrupted due to the ");
                    msg.append("failed decoding. Use debug level logging to ");
                    msg.append("see the original, non-corrupted values.");
                    log.warn(msg);
                }
            }
            tmpName.recycle();
            tmpValue.recycle();
            // Only recycle copies if we used them
            if (log.isDebugEnabled()) {
                origName.recycle();
                origValue.recycle();
            }
        } while( pos< end );
}

 public  void push() 
{
        // We maintain a linked list, that will grow to the size of the
        // longest include chain.
        // The list has 2 points of interest:
        // - request.parameters() is the original request and head,
        // - request.parameters().currentChild() is the current set.
        // The - >child and parent< - links are preserved ( currentChild is not
        // the last in the list )
        // create a new element in the linked list
        // note that we reuse the child, if any - pop will not
        // set child to null !
        if( currentChild==null ) {
            currentChild=new Parameters();
            currentChild.setURLDecoder( urlDec );
            currentChild.parent=this;
            return;
        }
        if( currentChild.child==null ) {
            currentChild.child=new Parameters();
            currentChild.setURLDecoder( urlDec );
            currentChild.child.parent=currentChild;
        } // it is not null if this object already had a child
        // i.e. a deeper include() ( we keep it )
        // the head will be the new element.
        currentChild=currentChild.child;
        currentChild.setEncoding( encoding );
}

Create ( or reuse ) a child that will be used during a sub-request. All future changes ( setting query string, adding parameters ) will affect the child ( the parent request is never changed ). Both setters and getters will return the data from the deepest child, merged with data from parents.

 public  void recycle() 
{
        super.recycle();
        paramHashStringArray.clear();
        didQueryParameters=false;
        currentChild=null;
        didMerge=false;
        encoding=null;
        decodedQuery.recycle();
}

 public  void setEncoding(String s) 
{
        encoding=s;
        if(debug >0) log( "Set encoding to " + s );
}

 public  void setHeaders(MimeHeaders headers) 
{
        this.headers=headers;
}

 public  void setQuery(MessageBytes queryMB) 
{
        this.queryMB=queryMB;
}

 public  void setQueryStringEncoding(String s) 
{
        queryStringEncoding=s;
        if(debug >0) log( "Set query string encoding to " + s );
}

 public  void setURLDecoder(UDecoder u) 
{
        urlDec=u;
}