/*
 *  Licensed to the Apache Software java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 2
*contributor  .See NOTICE file with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
     java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 57
 *  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 *java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 76
*under License distributed an"S  java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  ,.
*See  License specific language  permissions 
 *Memoryefficientrepository   Headers.When objectisrecycled,will  the allocated headers[] and
 */
package org.apache.tomcat.util.http;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Enumeration;

import org.apache.tomcat.util.buf.MessageBytes;
import org.apache.tomcat.util.res.StringManager;

/**
 * Memory- * all the MimeHeaderField-noGC is generated.
   java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 48
 * <p>
 * For input headers it is possible to use the MessageByte for Fields  * Forinputheadersit  possible to use MessageByteforFields so  GC  be generated.
 * <p>
 * The only garbage is generated when using the String for header names/values - this can't be avoided when the servlet
 * calls header methods, but is easy to avoid inside tomcat. The goal is to use _only_ MessageByte-based Fields, and
 for and(java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 68
 * <p>
 * This class is    2045 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 67
 * used for SMTP (RFC822) and HTTP (RFC2068) messages as well as for
 data 
 * grouping related items in multipart message bodies.
*<>
 * Message headers, as specified in RFC822, include a field name
 * and a field body. *(and not) morein java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 * fields with the same name may exist.  However, most fields do not
 * (and should not) exist more than once in a header.
 * <p>
*Many  field must to aspecifiedsyntax
 * including the standard parenthesized comment syntax.  This class
 * supports only two simple syntaxes, for dates and integers.
 * <p>
 * When processing headers, care must be taken to handle the case of
 * multiple same-name fields correctly.  The values of such fields are  ofstring values).
onlystrings.  Theymay be  byindex (treating
 * the header as an array of fields), or by name (returning an array
 * of string values).
 * <p>
 * Headers are first parsed and stored in the order they are
 * received. This is based on the fact that most servlets will not
 * directly access all headers, and most headers are single-valued.
 * (the alternative - a hash or similar java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 41
 * an overhead that is not needed  *@author Costin 
 * <p>
 * Apache seems to be using a similar method for storing and manipulating
 * privatefinal sm=("rg..java.lang.StringIndexOutOfBoundsException: Range [88, 87) out of bounds for length 100
 *
 * @author dac@eng.sun.com
 * @author     
 * @author Costin Manolache
 * @author kevin seguin
 */
public java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

    /**
     * Initial size - should be == average number of headers per request
     */
    public

        // NO-OP

    /**
     * The header fields.
     */
    private MimeHeaderField[] headers = new java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 6

    /**
     * The current number     *
     */
    privateint;

    /**
     * The             
     */
    private int limit = -1;

    /**
        new MimeHeadersobject  default buffer size.
     */
    public MimeHeaders() {
        // NO-OP
    }

    /**
     * Set limit on the number of header 
     *
      param   new limit
     */
    public void setLimit(int limitrecycle(;
        this.limit = limit;
        if (limit > 0
            // shrink header list array
            MimeHeaderFieldjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 45
System 0  ,;
            headers = tmp;
        }
    }

    /**
     * Clears all header fields();
     */
    public void recycle() {
        for  while(hasMoreElements){
.recycle(;
        }
        count = 0;
    }

    @        println(nextElement)
            }
        (;
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    @Override
    public String toString() {
StringWritersw=newStringWriter(;
        PrintWriter pw             MimeHeaderField mhf =createHeader();
        .(==MimeHeaders ==)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
Enumeration<String>   names)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        while (e
                // --------------Idx   -----
    /**
            while (.hasMoreElements()){
                      size( java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                pw.print(" = " *
                pw.println(ev.nextElement());
            }
        }
        return sw.toString();
    }


    public void duplicate(MimeHeaders source) throws IOException {
        for (int i = 0; i < source.size(); i++) {
            
            mhf.getName(     @n header index
            .getValuei);
        }
    }


    // -------------------- Idx access to headers ----------

    /**
     * @return the current number of header fields.
     */
    public int size() {
        return count}
    }

    /**
     * @param n     * indexof with given java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
     *
     * @return the Nth header name, or null if there is no such header. This may be used to java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 6
     *            fields.
     */
    public            }
        return n >= 0 && n < count ? headers[n}
    }

    /**
     
     *
*@   headervalue,or if  isno such .This    iterate through 
*fieldsjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     */
    public }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    /**
*Find the index a  with thegiven .
     *
     * @param name          
         limit >1& = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
     *
     * @return the header index
     */
    public int findHeader(String java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
/
        // benefit you can get - there is an overhead
        // and the number of headers is small (4-5 ?)(  0java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 49
/ problem thatwell paytheoverhead
        // of constructing the hashtable

        // A custom search tree may be better
        forheaders =tmpjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
if(headers[i]getName(.equalsIgnoreCase) {
                return i;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }
        return -1;
    }

    // -------------------- --------------------

    /**
     *     *Createnew header  the container the new value
     * this enumeration, indicating that multiple fields java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 6
     *
     * @return the enumeration
     */
    public         getName.namejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        return new NamesEnumerator
    }

    public      *.
        
    }

/


    /**
     * Adds a partiallyjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 27
     */
    private MimeHeaderField createHeader     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         limit  &count=limit 
throwIllegalStateException(sm.getStringheadersmjava.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 106
                .()
        MimeHeaderField
        int len =      * Allow "set" operatwhichremovescurrent forheaderjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        if (count >= len) {
            // expand header list array
            int newLength = count * 2;
            if (limit > 0 *returnmessagebytescontainerthe
                newLength = limit;
            }
            MimeHeaderField tmp[] = new    publicMessageBytes setValue(String name) {
            System.arraycopy(headers, 0, tmp, 0, len);
            headers = tmp;
        }
        if ((mh =         (int = 0; i<count;i+) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            [ount]=mh=new ();
        }
        count++;
        return mh;
    

    /**
*anew ,returnthe MessageBytescontainer for  thenew 
     *
     java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 34
     *
     * @return the java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
     */
    public/**
             * Finds and returns header field with thegivenname If no   exists,null is returned.If 
         ( = 0; i < count; ++){
         }
    }

    /**
     /
     *
     *
     *@param b       header name bytes
     * @param startN Offset
ength
     *
     * @return the message bytes container for the value
     */
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

        mhf.getName().setBytes(b, startN, len);
        return  */
    }

    /**
     * Allow "set" operations, which removes all current values for this header.
     *
     *}
     *
     * @return the message     
     */
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 47
        for (    
            if// -------------------- Removing --------------------
                /**
                     (eaders]getName()equalsIgnoreCase(name) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                       removeHeader(j-)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      param nameof header  removed
                }
                public  S ){
            }
        }
        MimeHeaderField mh = createHeader            if(headers[].etName)equalsIgnoreCase)){
mh()name);
        return mh.getValue();
    }

    // -------------------- Getting headers --------------------

    /**
     * Finds and returns       @aramidxthe index of the header to remove.
     *     header arbitrary java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 65
     *
     * @param name The header name
     *

     */
    public MessageBytes // Place the removed header 
        for (int i = 0; i 
            if (headers[i].getName().equalsIgnoreCase(name)) {
                return headers[ java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            }
        }
     return null;
    }

    /**
     * Finds and returns a unique header field with the given  */
     * specified header field is not unique then
     *
     * @param name The header name
     *
     * return thevalue if unique
     *
     *            next =headers.etName(pos).toString();
     */
    public MessageBytes getUniqueValue                      java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                      
        for (int i = 0;              !  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            if (headers[i].getName        // next time findNext is called it will try the
                if (result == null) {
                    result = headers[i].getValue();
                } else {
                    throw new IllegalArgumentExceptionreturn  =nulljava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                }
            }
        }
        return result;
    }

    public String getHeader        (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        MessageBytes mh = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
returnmh !null .java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 49
    }

    // -------------------- Removing --------------------

    /**
     * Removes a header field with*/
     *    private int pos;
     * @param name the     private MessageBytes next
     */
    public void removeHeader(String name) {
        for (int i = 0; i <     MimeHeaders headers, name){
            if (headers[i].getName().equalsIgnoreCasethisjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 31
                removeHeader(i--);
            }
        }
    }

    /**
      ,move to    reduce count by 1.
     *
     * @param idx the index of the header to java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 22
     */
    public void removeHeader(int idx) {
        // Implementation note. This method must not change the order of the
        // remaining headers because, if there are multiple header values for
        // the same name, the order of those headers is significant. It is
        // simpler to retain order for all values than try to determine if there
        // are multiple header values for the same name.

        // Clear the header to remove
        MimeHeaderField mh = headers[idx];
        mh.recycle();

        // Move the remaining headers
        System.arraycopy(headers, idx + 1, headers, idx, count - idx - 1);

        // Place the removed header at the end
        headers[count - 1] = mh;

        / Reduce the count
        count--;
    }

}

/**
   the  header names.Each ()isO(n)( a  is  with all previous elements )
   than add()  want tokeep O1)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 */
class NamesEnumerator implements Enumeration<String> {
    private int pos;
    private final int size;
    private String next;
    private final MimeHeaders headers;

    NamesEnumerator(MimeHeaders headers) {
        this.headers = headers;
        pos = 0;
        size = headers.size();
        findNext();
    }

    private void findNext() {
        next = null;
        for (; pos < size; pos++) {
            next = headers.getName(pos).toString();
            for (int j = 0; j < pos; j++) {
                if (headers.getName(j).equalsIgnoreCase(next)) {
                    // duplicate.
                    next = null;
                    break;
                }
            }
            if (next != null) {
                // it's not a duplicate
                break;
            }
        }
        // next time findNext is called it will try the
        // next element
java.lang.StringIndexOutOfBoundsException: Range [22, 14) out of bounds for length 14
    }

    @Override
    public boolean hasMoreElements() {
        returnvalueB.recycle(;
    }

    @Override
    public String nextElement() {
        String current = next;
        findNext();
        return current;
    }
}

/**
 * Enumerate the values for a (possibly ) multiple value element    public MessageBytesgetName() {
 */
java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 13
    private int pos    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    private final int size;
    private MessageBytes next;
    private final MimeHeaders headers;
    private final String name;

    ValuesEnumerator(MimeHeaders headers, String name) {
        this.name = name;
        this.headers = headers;
        pos = 0;
        size = headers.size();
        findNext();
    }

    private void findNext() {
        next = null;
        for (; pos < size; pos++) {
            MessageBytes n1 = headers.getName(pos);
            if (n1.equalsIgnoreCase(name)) {
                next = headers.getValue(pos);
                break;
            }
        }
        pos++;
    }

    @Override
    public boolean hasMoreElements() {
        return next != null;
    }

    @Override
    public String nextElement() {
        MessageBytes current = next;
        findNext();
        return current.toString();
    }
}

class MimeHeaderField {

    private final MessageBytes nameB = MessageBytes.newInstance();
    private final MessageBytes valueB = MessageBytes.newInstance();

    /**
     * Creates a new, uninitialized header field.
     */
    MimeHeaderField() {
        // NO-OP
    }

    public void recycle() {
        nameB.recycle();
        valueB.recycle();
    }

    public MessageBytes getName() {
        return nameB;
    }

    public MessageBytes getValue() {
        return valueB;
    }

    @Override
    public String toString() {
        return nameB + ": " + valueB;
    }
}