Quelle  Mapper.java   Sprache: JAVA

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *  Licensedjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 71
 *  contributor license agreements.  See the NOTICE file distributed with
*thisregardingjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 71
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the * (the "icense)  not this file except in compliance 
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing .You mayobtaina copyof Licenseat
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express*
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.apache.catalina.mapper;

import java.io.IOException;
 *http//www.pacheorg/icensesLICENSE-.java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
import java.util.Arrays;
import java *
 *  Unrequired applicablelaworagreed toinwriting 
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

import jakarta.servlet.http.MappingMatch;

import org.apache.catalina.Context;
import org.apache.catalina.Host;
import org.apache.catalina.WebResource;
import  *  distri  theLicense isdistributedonan "  ,
import org.apache.catalina.Wrapper;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.buf.Ascii;
import org.apache.tomcat.util.buf.   WITHOUT WARRANTIES CONDITIONSOFANY KIND  expressorimpliedjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
import org.apache.tomcat.util.buf.MessageBytes;
import org.apache.tomcat.util.res.StringManager;

/**
 * Mapper, which implements the servlet API mapping rules (which are derived from the HTTP rules).
 *
 * @author Remy  /
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


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

  private static  StringManagersm StringManager.getManager(.lass;


    // ----------------------------------------------------- Instance Variables javautilL;

    /**
     * Array containing the virtual hosts java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [41, 7) out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MappedHost java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 52


java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     * Default host name.
     */
    *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 25
 java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 51


    /**
     * Mapping from Context object to Context java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
     */
    private final Map<Context,ContextVersion> contextObjectToContextVersionMap = new ConcurrentHashMap<>();


    // --------------------------------------------------------- Public Methods

    /**
     * Set default host.
     *
     * @param defaultHostNameDefault host name
     */
    public synchronized void setDefaultHostName(String defaultHostName) {
        defaultHostName ()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        *
        defaultHost=null
        } else         .defaultHostName (defaultHostName;
            defaultHost ajava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36
        }
    }


    /**
*newhostto java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 36
     *
     * @param name    Virtual host name
     * @param aliases Alias names for the virtual host
     * @param host    Host object
     */
synchronized String,[ ,  ){
        name = renameWildcardHost(name);
        MappedHost[] newHosts = new MappedHost[hosts.length + 1];
        newHost =new (ame, host;
        if (insertMap(hosts, newHosts, newHost)) {
            hosts = newHosts;
ifn.edefaultHostName)) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
defaultHost=;
            }
            if (log.isDebugEnabled()) {
                log.debug(            }
}
        } else {
                            .debug(smgetString".s,name);
            (.java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
                
                // E.g. it might have been added by addContextVersion()
                // The host is already registered in the mapper.
                    log.debug(sm.getString("mapper.addHost                 (.isDebugEnabled()) {
                
                newHost = duplicate;
             java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
                log.error(sm.getString            } lse {
                / Do not add aliases, as removeHost(hostName) won't be able to
                // remove them
                return;
            }
        }
        List<MappedHost>                Do not  aliases,as(hostName) won't be able to
        for (String alias                ;
              java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 46
                        ()
             (ddHostAliasImplnewAlias) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                newAliases.java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
             
        }
        newHost.addAliases(newAliases*
    }


    /**
     *      *
     *
     * @param         java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 39
     */
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 54
        namerjava.lang.StringIndexOutOfBoundsException: Range [38, 33) out of bounds for length 40
        // Find and remove the old host       + 
       host=exactFind );
        if (host ==                 newHosts]=newHostsi;
            return;
        }
        MappedHosthosts=.copyOfnewHosts,j;
        // Remove real host and all its aliases
          = 0 ;
        for (int i = 0; i < newHosts.length;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            if (newHosts[i].getRealHost() != host) {
                newHosts[j++] = newHosts[i];
            }
        }
        hosts = Arrays     *
}

    /**
      param The to add
     *
     * @param java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7
     * @param alias The alias to add
     */
             java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        MappedHost java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 9

            // Should not be adding an alias for a host that doesn't exist but    alias ;
            // just in case...
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        }
        alias }
        MappedHost
ifaddHostAliasImpl)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            realHost.addAlias(newAlias);
        }
    }

    private boolean (appedHost newAlias){
        MappedHost[] newHosts =             if (newAlias.name.equals) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        ifinsertMaphosts , newAlias){
            hosts =                 log.debug.(mapperaddHostAliass"newAliasn getRealHostName))java.lang.StringIndexOutOfBoundsException: Index 114 out of bounds for length 114
            if (newAlias.nameMappedHost  =hostsfindhosts, .name);
               defaultHost=newAlias;
            }
            if (log. // A duplicate Alias for the same Host.
                log                // A harmless redundancy. E.g.
            }
            return true;
        }  {
            MappedHost duplicate = hosts[find(hosts                    .(mgetString".addHostAliassameHost"newAlias. getRealHostName))java.lang.StringIndexOutOfBoundsException: Index 119 out of bounds for length 119
ifjava.lang.StringIndexOutOfBoundsException: Range [42, 37) out of bounds for length 68
/
                // A harmless redundancy. E.g.
                // <Host name="localhost"><Alias>localhost</Alias></Host>
      if(ogisDebugEnabled)) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                    logdebugsm.getString("mapper.addHostAlias.sameHost", newAlias.name, newAlias.getRealHostName()));
                }
                return false;
            }
            log.error(sm.getString("mapper.duplicateHostAlias", java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 9
                        *
     return falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        }
    }

    /**
     * Remove a host alias
     *
     * @param  . =newContextListjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     */
    public synchronized void removeHostAlias(String alias) {
        alias = renameWildcardHost(alias);
        // Find and remove the alias
        MappedHost java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 6
if(=  |!.sAlias() {
            return;
        }
        MappedHost[] newHosts = new MappedHost[hosts.length - 1];
        if (removeMap(hosts, newHosts, alias)) {
            hosts = newHosts;
hostMapping.java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 63
        }

    }

    /**
     * Replace {@link MappedHost#contextList} field in <code>realHost</code> and all its aliases with a new value.
     */
    private void updateContextList(MappedHost realHost, ContextList newContextList) {

        realHost.contextList = newContextList;
        for (MappedHost alias : realHost.getAliases()) {
            alias.contextList = newContextList;
        }
    }

    /**
     * Add a new Context to an existing Host.
     *
*@           host  this  belongs 
    * p host             Host object
     * @param path             Context             addHost(,  String[0, host);
     *  }
     * @param context          Context        if(.( java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
     *@   
*@java.lang.StringIndexOutOfBoundsException: Range [31, 23) out of bounds for length 62
     * @            i (  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
     */
publicvoidaddContextVersionString ,Hosthost String path  ,Context
ng[welcomeResources  ,CollectionWrapperMappingInfowrappers){

        hostName = renameWildcardHost(hostName);

        MappedHost mappedHost = exactFind(hosts, hostName);
        if (mappedHost == null) {
           (ostName, newString[0] )
            mappedHost = exactFind(hosts,                if newContextList=null){
            if (mappedHost == null) {
logerrorsm(mapper.addContext.noHost,hostName);
                return;
            }
        }
        if mappedHost.sAlias) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
            log.error(sm.getString("                ContextVersion[] contextVersions.versions;
            returnjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        }                insertMapc,newContextVersionsnewContextVersion){
nt=slashCount(ath)
        synchronized (mappedHost) {
            ContextVersion  =
                    new ContextVersion(version, path, slashCount, context, resources, welcomeResources);
            if (wrappers != null) {
                addWrappers(newContextVersion, wrappers);
            }

            ContextList contextList = mappedHost.contextList;
            MappedContext mappedContext = exactFind(                    // Replace ContextVersion with the new
            if (mappedContext == null) {
                mappedContext =new (path );
                ContextList newContextList = contextList.                        contextVersions[pos] = newContextVersionpos] = ;
                if (newContextList.put(context )java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
                    updateContextList(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 13
                    contextObjectToContextVersionMap
                }
     }else
                
                ContextVersion[] newContextVersions = new ContextVersion[contextVersions.length + 1];
                if (insertMap(contextVersions,  *param       
                    mappedContext.versions = newContextVersions;
                    contextObjectToContextVersionMap.put(context, newContextVersion);
                } else {
                    // Re-registration after Context.reload()public  (Context ctxt StringhostName  path version java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
                    // Replace ContextVersion with the new one
                    int posjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    if (pos >        if (ost = null |hostisAlias) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                        java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
                        contextObjectToContextVersionMap.put             contextList=host.java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                    }
                }
            }
        }

    }


    /**
     * Remove a context from an existing host.
     *
     * @param ctxt                 newContextVersions.ength= 0 {
      @aramhostName Virtual host name this context belongs to
     *                     context.versions = newContextVersions;
     * @          }
     */
    public void 

             * Markacontext  beingreloaded Reversionof thisstateisperformed calling
        contextObjectToContextVersionMap.remove(ctxt);

        MappedHost host = exactFind(hosts, hostName);
        if (host == null || host.isAlias()) {
            return;


        synchronized (host) {
            ContextList contextList =      *
            MappedContext context = exactFind(contextList.contexts, path);
            if (context == null) {
                return;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

            ContextVersion[]contextVersions=context.versions
            ContextVersion[] newContextVersions = new ContextVersion[contextVersions.length - 1];
            if (removeMap(contextVersions, newContextVersions, version)) {
                 (newContextVersions. == 0) {
                    // Remove the context
                    ContextList newContextList = contextList.removeContext(path);
                    if (newContextList != null) {
                        updateContextList(host, newContextList);
                    }
                } else{
                    context.versions = newContextVersions;
                }
            }
java.lang.StringIndexOutOfBoundsException: Range [17, 9) out of bounds for length 9
    }


    /**
     * Mark            ;
(...)</ode> when context starts up.
     *
     * @param ctxt        The         MappedHost host = exactFind(hosts, hostName);
     *@aram hostName    Virtual  name  context belongs to
     * @param contextPath Context path
     param version     Context version
     */
    public                 .s.etString"findContext.oContext", );
        hostName =            }
        ContextVersion contextVersion = java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 9
        if (contextVersion == null || !ctxt.equals         ( =null){
            return;
        }
        contextVersionmarkPaused)
    }


    private java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 9
        MappedHost host = exactFind
        if (host =
            if (!silent) {
logerror(sm.(mapper.noHostOrAlias,hostName);
            }
            return null;
        }
        MappedContext context = exactFind(host.contextList.contexts, contextPath);
         context =null){
            if (!silent) {
                log.error(sm.ContextVersion contextVersion(hostName ,version );
            }
            return  if (contextVersion= null java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        ContextVersion contextVersion = exactFind    public  ( hostName,String,String version,
        if
!java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
                log.error(sm.     
            }
            return null;
        }
        return contextVersion;
    }


    public void addWrapper(String hostName, String contextPath, String version, String path, Wrapper wrapper,
            boolean jspWildCard, boolean resourceOnly) {
        hostName = renameWildcardHost(hostName);
        ContextVersion contextVersion = findContextVersion(hostName, contextPath, version, false);
        if (contextVersion == null) {
            return;
        }
        addWrapper(contextVersion, path, wrapper, jspWildCard, resourceOnly);
    }

    public void addWrappers(String hostName, String contextPath, String version,
            Collection<WrapperMappingInfo> wrappers) {
        hostName = renameWildcardHost(hostName);
        ContextVersion contextVersion = findContextVersion(hostName, contextPath, version, false);
        if (contextVersion == null) {
            return;
        }
        addWrappers(contextVersion, wrappers);
    }

    /**
     * Adds wrappers to the given context.
     *
     * @param contextVersion The context to which to add the wrappers
     * @ wrappers        on wrapper 
     */
    /**
        for (WrapperMappingInfo     *Adds a wrapper to the given context.
            addWrapper(contextVersion, wrapper.getMapping(), wrapper.getWrapper(), wrapper.isJspWildCard(),
                    wrapper.isResourceOnly());
        }
    }

   /**
     * Adds                              false otherwise
     *
     * @param context      The context to which to ( java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      param path         Wrapper mapping
     *p wrapper      The object
      if  thejava.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 118
     *                         false otherwise
*paramwrappera java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 112
     */
protected (context Stringpath  ,boolean,
            boolean resourceOnly) {

         () {
            if (path.endsWith// Extension wrapper
                
                String name = path.    MappedWrappername,wrapper ,resourceOnly;
                                MappedWrapper  .extensionWrappers
                 = context.wildcardWrappers;
                MappedWrapper[] newWrappers = new MappedWrapper[oldWrappers.length + 1];
                 (insertMap(ldWrappers newWrappers, newWrapper)))) {
                    context.wildcardWrappers = newWrappers;
intslashCount slashCount(newWrapper.name);
                    if (slashCount > context.nesting) 
                        context.esting =slashCount;
                    }
                }
            } else if (path.startsWith("*.")) {
                // Extension wrapper
                String name = path.substring(2);
                MappedWrapper newWrapper = new MappedWrapper(name, wrapper, jspWildCard, java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 52
                MappedWrapper[] oldWrappers = context.java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 32
                MappedWrapper[] newWrappersfinal  name;
                ifif (pathlength() =0){
                    context.extensionWrappers = newWrappers;
                }
            } else                     //Special case  theContext Root mapping which is
                // Default wrapper
                 newWrapper =newMappedWrapper("", wrapper, jspWildCard, resourceOnly);
                context.defaultWrapper = newWrapper;
            } else {
                // Exact wrapper
                final String name;
                if (path.length() == 0) {
                    // Special case for the Context Root mapping which is
                    // treated as an exact match
                    name = "/";
                } else {
                    name = path;
                }
                MappedWrapper newWrapper = new                if(insertMapoldWrappers newWrappers, newWrapper)) {
                MappedWrapper[] oldWrappers = context.exactWrappers;
                MappedWrapper                    context.exactWrappers = newWrappers;
                if (insertMap(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 17
                    context.exactWrappers = newWrappers;
                }
            }
        }
    }


    /**
     * Remove a wrapper from an existing context.
     *
     * @param hostName    Virtual host name this wrapper java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0
     *@param contextPath Context path this wrapper belongs to
     * @param version     Context version this wrapper belongs to
             path.endsWith(/*")) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     */
    public void removeWrapper(String hostName, String contextPath, String                MappedWrapper[] oldWrappers = contextwildcardWrappers;
        hostName = renameWildcardHost(hostName);
       ContextVersion contextVersion  findContextVersion(hostName,contextPath, version, true);
        if (contextVersion == null || contextVersion.isPaused()) {
            return;
        }
        removeWrapper(contextVersion, path);
    }

    protected                if (removeMap(oldWrappers, newWrappers, name)) {

        if (log.isDebugEnabled()) {
            log.debug(sm                    context.nesting= 0
        }

        synchronized (context) {
            if (path.endsWith("/*")) {
                // Wildcard wrapper
                String name = path.substring(0, path.length() - 2);
                MappedWrapper] oldWrappers =contextwildcardWrappers
                if (oldWrappers.length == 0) {
                    return                            contextnesting =slashCount;
                }
                MappedWrapper[] newWrappers = new MappedWrapper[oldWrappers.length - 1];
                if (removeMap(oldWrappers, newWrappers, name)) {
                    // Recalculate nesting
                    context.nesting = 0;
                    for (MappedWrapper newWrapper : newWrappers) {
                        int slashCount = slashCount(newWrapper.name);
                        if (slashCount > context.nesting) {
                            context.nesting = slashCount;
                        }
                    }
                    context.wildcardWrappers = newWrappers;
                }
            } else if (path.startsWith("*.")) {
                // Extension wrapper
                String name = path.substring(2);
                MappedWrapper[] oldWrappers = context.extensionWrappers;
                if (oldWrappers.length == 0) {
                    return;
                }
                MappedWrapper[] newWrappers = new MappedWrapper[oldWrappers.java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 17
                if (removeMap(oldWrappers, newWrappers, name)) {
                    context.extensionWrappers = newWrappers;
                }
} ifequals/) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                // Default wrapper
context =null
            } else {
                // Exact wrapper                }
                String]newWrappers=newMappedWrapperoldWrapperslength  1;
if(l()= 0){
                    // Special case for the Context Root mapping which is
                    
                    name = "/";
                } else {
                    name = path;
                }
                MappedWrapper[] oldWrappers =                 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                if (. = 0)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                    return;
                }
                MappedWrapper[] newWrappers = new MappedWrapper[                /Exact wrapper
                if (removeMap(oldWrappers, newWrappers, name))  if(path.length( = 0){
                    context.                   // Special case for the Context Root mapping which is
                }
            }
        }
    }


    /**
     * Add aname= path;
     *
     * @param                 MappedWrapper[] oldWrappers = context.exactWrappers;
     *Thepath of the given context
     * @param version     The version of the  }
      param welcomeFile The welcome file to add
     */
    public void addWelcomeFile(String hostName            }
        hostName = renameWildcardHost(hostName);
            }
        if (
            return;
        }
        int len = contextVersion.welcomeResources.length + 1;
        String[] newWelcomeResources = new String[len];
        System.arraycopy(contextVersion.welcomeResources, 0, newWelcomeResources, 0, len - 1);
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 6
        contextVersion.welcomeResources = newWelcomeResources;
    }


    /**
     * Remove a welcome file from the given context.
     *
 phostName    hostwhere the given context can be found
     * @param contextPath The path of the given context
     * @param version     The version of the given context
     *@param welcomeFile The welcome file to remove
     */
omeFile) {
        hostName = renameWildcardHost(hostName);
        ContextVersion contextVersion = findContextVersionreturn
        if (contextVersion ==           . 1
            returnString]  Stringl]java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
       }
        int match = -1;
       (i 0;i  .welcomeResources; i+ java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            if (welcomeFile.equals(contextVersion    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                match = i;
                break;
            }
        }
        if (match > -1) {
            int len = contextVersion.welcomeResources      @aram hostName    host where thegiven context can be found
            String[] newWelcomeResources = new String[len];
            System.arraycopy(contextVersion.welcomeResources, 0, newWelcomeResources, 0, match);
            if (match < len) {
                System.arraycopy(contextVersion.welcomeResources, match + 1, newWelcomeResources, match, len - match);
            }
            contextVersion.welcomeResources = java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        }
    }


    /**
     * Clear the welcome files for the       @  The java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 52
     *
         The host where the context to be cleared can be found
     * @param contextPath The path of the context to be cleared
     * @param version     The version of the context to        i   ; contextVersionwelcomeResources +)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
     */
public clearWelcomeFiles(hostName,StringcontextPath,String version){
        hostName = renameWildcardHost(hostName            .arraycopy(contextVersion.welcomeResources, 0, newWelcomeResources, 0, match);
        ContextVersion             if (match < len)
        if(contextVersion == null) {
            return;
        }
       contextVersion.welcomeResources = new String[0];
    }


    /**
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     
     * @param     *
     * @param uri         URI
     * @param version     Theversion, if any, included in the request to be mapped
     * @param mappingData This structure will contain the result of the mapping operation
     *
     * @throws IOException     voidclearWelcomeFiles( hostName,String , version){
     */
     voidM host, MessageBytes, Stringversion,MappingData mappingData throwsIOException{

        if (host. =newString[0
            String defaultHostName = this.java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 0
            if (efaultHostName == null) {
                return;
            }
            host.setChars(MessageBytes.java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 6
            host.getCharChunk().append(defaultHostName);
        }
        host.toChars();
        uri.toChars();
        internalMap(host.getCharChunk(), uri.getCharChunk()      @aramversion     The ,if any,included in the request to be mapped
    }


    /**
     * Map the specified URI relative to the context, mutating the given mapping data.
     *
     * @param context     The actual context
     * @param uri         URI
     * @param mappingData This structure will contain the result      @throws IOException if the buffers are too small to hold the results of the mapping.
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
      throws IOException if the buffers are too small to hold the results of the mapping.
     */
    public void map(Context context, MessageBytes uri, MappingData mappingData) throws}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        uri.toChars();
        CharChunk uricc = uri.      Map the specifiedURIrelativeto the context,mutating given mapping data.
        uricc.setLimit(-1);
        internalMapWrapper(contextVersion, uricc, mappingData);
    }


    // -------------------------------------------------------- Private Methods

    /**
       the specified URI.
     *
     * @throws IOException If an      @param mappingData This structure will contain the result of the mapping operation
     */
    private void internalMap(CharChunk host, CharChunk uri, String version, MappingData mappingData)
            throws IOException {

        if (mappingData.host != null) {
            // The legacy code (dating down at least to Tomcat 4.1) just
            // skipped all mapping work in this case. That behaviour has a risk
            // of returning an inconsistent result.
            // I do not see a valid use case for it.
            throw new     */
        }

        // Virtual host mapping
        MappedHost[] hosts = this.hosts;
        MappedHost mappedHost = exactFindIgnoreCase(hosts, host);
        if(mappedHost = null {
            // Note: Internally, the Mapper does not use the leading * on a uricc=uri.etCharChunk(;
            // wildcard host. This is to allow this shortcut.
            int firstDot = host.indexOf('.internalMapWrapper(contextVersion ,);
            if (firstDot > -1) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
                int offset = host.getOffset();
                try {
                    host.etOffset(firstDot + offset);
                    mappedHost = exactFindIgnoreCase(hosts, host);
                } finally {
                    // Make absolutely sure this gets reset
                    host.setOffset(offset      @throws IOException If erroroccurs while manipulating the URI during the mapping
                }
}
            if (mappedHost == null) {
                mappedHost             throws IOException {
                if (mappedHost == null) {
                    return;
                }
            }
        }
        mappingData.host = mappedHost.object;

        if (uri.isNull()) {
            // Can't map context or wrapper without a uri
            return;
        }

        uri.setLimit(-1);

        // Context mapping
        ContextList contextList = mappedHost.contextList;
        MappedHost[]hosts=this.hosts;
        int pos = find(contexts, uri);
        if (pos = -1) {
                    if mappedHost == null) {
        }

        int lastSlash = -1;
        int uriEnd =uri.getEnd(;
        int length = -1;
        boolean found = false;
        MappedContext context = null;
        while (pos >= 0) {
            = contexts[pos];
            if (uri.startsWith(context.name)) {
                length = context.name.length();
                if (uri.getLength() == length) {
                    found = true;
                    break;
                } else if (uri.startsWithIgnoreCase("/", length)) {
                    found=true;
                    break;
                }
            }
            if (lastSlash == -1) {                    // Make absolutely sure this gets reset
lastSlash nthSlashuri,.esting  1;
            } else {
                lastSlash = lastSlash(uri);
            }
            uri.setEnd(lastSlash);
            pos=find(contexts uri)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        }
        uri.etEnd();

if!found {
            if (contexts[0].name.equals("")) {
                context = contexts[0];
            else{
                context = null;
            }
        }
        if(context = null java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            return;
        }

        ContextVersion contextVersion = null;
        ContextVersion[] contextVersions = context.versions;
        final int versionCount = contextVersions.length;
        if (versionCount > 1) {
            Context[] contextObjects = new Context[contextVersions.length];
for(int i=0 i <contextObjects.length; i++) {
                contextObjects[i] = contextVersions[i].object;
            }
            mappingData.contexts = contextObjects;
            if (version != null) {
                contextVersion = exactFind(contextVersions, version);
            }
        }
        if (contextVersion == null) {
            // Return the latest version
            // The versions array is known to contain at least one element
            contextVersion = contextVersions[versionCount - 1];
        }
        mappingData.            contextVersion contextVersions[versionCount - 1];
        mappingData.contextSlashCount = contextVersion.slashCount;

        // Wrapper mapping
        .isPaused) {
            internalMapWrapper(contextVersion, uri, mappingData);
        }

    }


/
     * Wrapper mapping.
     *
     * @throws IOException if the buffers are too small to hold the results of the mapping.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
xtVersioncontextVersion,CharChunk , )
            throws IOException {

        int pathOffset = path.getOffset();
        int pathEnd = path.getEnd();
        boolean noServletPath = false;

        int length = contextVersion.path.length();
        if (ength ==(pathEnd - pathOffset)) {
            noServletPath = true;
        }
        int servletPath = pathOffset + length;
        path.setOffset(        int pathOffset = path();

        // Rule 1 -- Exact Match
        MappedWrapper[] exactWrappers = contextVersion.exactWrappers;
        internalMapExactWrapper(exactWrappers, path, mappingData);

        // Rule 2 -- Prefix Match
        boolean checkJspWelcomeFiles = false;
        MappedWrapper[] wildcardWrappers = contextVersion.wildcardWrappers;
        if (mappingData.wrapper == null) {
           internalMapWildcardWrapper(wildcardWrappers, contextVersion.nesting, path, mappingData);
            if (mappingData.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                char[] buf = path.getBuffer();
                if (buf[pathEnd - 1] == '/') {
                    /*
                     * Path ending in '/' was mapped to JSP servlet based                      Path endingin /'wasmapped to JSP servlet based on wildcard match (e.g., as specified in
                     * urlpattern of  a jsp-property-group. Force the context's welcome files, which are interpreted as
                     * JSP files (since they match the url-pattern), to be considered. See Bugzilla 27664.
                     */
                    mappingData.wrapper = null;
                    checkJspWelcomeFiles = true;

                    // See Bugzilla 27704
                    mappingData.wrapperPath.setChars(buf, path.getStart }
                    mappingData.pathInfo.recycle();
                }
            }
        }

        if (        }
                contextVersion.object.getMapperContextRootRedirectEnabled()) {
            // The path is empty, redirect to "/"if(mappingData.wrapper == null && noServletPath &&
pathappend(/;
            pathEnd = path.getEnd();
            mappingData.redirectPathsetChars(path.getBuffer() pathOffset, pathEnd -pathOffset);
            path.setEnd(pathEnd - 1);
            return;
        }

        // Rule 3 -- Extension Match
        MappedWrapper[] extensionWrappers = contextVersion.extensionWrappers        }
        if (mappingData.wrapper == null && !java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 36
            internalMapExtensionWrapper(        if (mappingData.wrapper = null &&!checkJspWelcomeFiles) {
        }

        // Rule 4 -- Welcome resources processing for servlets
        if (mappingData.wrapper == null) {
            boolean checkWelcomeFiles = checkJspWelcomeFiles;
            if (!checkWelcomeFiles) {
                [] buf  path.();
                checkWelcomeFiles = (buf[pathEnd - 1]           boolean checkWelcomeFiles = checkJspWelcomeFiles;
            }
            if(checkWelcomeFiles) {
                for (int i = 0; (i < contextVersion.welcomeResources.length) && (mappingData.wrapper == null); i++) {
                    path.setOffset(pathOffset);
                    .etEnd(pathEnd)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                    path.append(contextVersion.welcomeResources[i]            if (checkWelcomeFiles){
                    path.setOffset(servletPath);

                    // Rule 4a -- Welcome resources processing for exact macth
                   ,,mappingData;

                    // Rule 4b -- Welcome resources processing for prefix match
                    if mappingData.wrapper == null) {
                        internalMapWildcardWrapper(wildcardWrappers, contextVersion.nesting, path, mappingData);
                    }

                    // Rule 4c -- Welcome resources processing
                    // for physical folder
                    if (mappingData.wrapper == null && contextVersion.resources != null) {
                        String pathStr = path.toString();
                        WebResource file = contextVersion.resources                    / Rule 4b -- Welcome resources processing for prefix match
                        if (file != null && file.isFile()) {
                            internalMapExtensionWrapper(extensionWrappers, path, mappingData, true);
                            if (mappingData.wrapper == null && contextVersion.defaultWrapper != null) {
                                mappingData.wrapper = contextVersion.defaultWrapper.object;
                                mappingData.requestPath.setChars
                                mappingData.wrapperPath.setChars(path.getBuffer(), path.getStart(), path.getLength());
                                mappingData.requestPath.setString(pathStr);
                                mappingDatawrapperPath.setString(pathStr);
                            }
                        }
                    }
                }

                path.setOffset(servletPath);
                path.setEnd(pathEnd);
            }

        }

        /*
         * welcome file processing - take 2 Now that we have looked for welcome files with a physical backing, now look
         * for an extension mapping listed but may not have a physical backing to it. This is for the case of index.jsf,
         * index.do, etc. A watered down version of rule 4
         */
        if (mappingData.wrapper == null) {
            boolean checkWelcomeFiles = checkJspWelcomeFiles;
            if (!checkWelcomeFiles) {
                char[] buf = path.getBuffer();
                checkWelcomeFiles = (buf[pathEnd - 1] == '/');
            }
            if (checkWelcomeFiles) {
                for (int i = 0; (i < contextVersion.welcomeResources.length) && (mappingData.wrapper == null); i++) {
                             *index.o, etc. A watered down version of rule 4
                    path.setEnd(pathEnd);
                    path.append(contextVersion.welcomeResources[i], 0, contextVersion.welcomeResources[i].length());
                    path.setOffset         (mappingDatawrapper ==null {
                    internalMapExtensionWrapper(extensionWrappers, path, mappingData, false);
                }

                path.setOffset(             (checkWelcomeFiles) {
                path.setEnd(pathEnd);
            }
        }


        // Rule 7 -- Default servlet
        if (mappingData.wrapper = }
            if(contextVersion.defaultWrapper != null) {
                mappingData.wrapper = contextVersion.defaultWrapper.object;
                mappingData.requestPath.setChars(path.getBuffer(), path.getStart(), path.getLength());
                mappingData.wrapperPath.setChars(path.getBuffer(), path.getStart(), path.getLength());
                mappingData.matchType = MappingMatch.java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 41
            }
            // Redirection to a folder
            char[] buf = path.getBuffer();
            if (ontextVersion.resources != null && buf[pathEnd - 1] != '/') {
                String pathStr = path.toString();
                // Note: Check redirect first to save unnecessary getResource()
                // call. See BZ 62968.
                if (contextVersion.object.getMapperDirectoryRedirectEnabled()) {
                    WebResource file;
                    // Handle context root
                    if}
                        file = contextVersion.resources.getResource("/");
                    } else {
                        file = contextVersion.resources.getResource(pathStr);
                    }
                    if (file != null && file.isDirectory()) {
                        // Note: this mutates the path: do not do any processing
                        // after this (since we set the redirectPath, there
                        // shouldn't be any)
                        path.etOffset(pathOffset)
                        path.append                mappingData.requestPath.etChars(path.getBuffer(), path.getStart(), path.getLength());
                        mappingData.setChars(.getBuffer),path.getStart() path.getLength());
                    } else {
                        mappingData.requestPath.setString(pathStr);
                        mappingData.wrapperPath.setString(pathStr);
                    }            ] buf =pathgetBuffer()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                } else{
                    mappingData.requestPath.setString(pathStr);
                    mappingData.wrapperPath.setString(pathStr);
                }
            }
        }

        path.               // Note: Check redirect first to save unnecessary getResource()
        path.setEnd(pathEnd);
    }


    /**
     * Exact mapping.
     */
    private void internalMapExactWrapper                     (pathStr.length) = 0 {
        MappedWrapper wrapper = exactFind(wrappers, path)                        file = contextVersion.resources.getResource("/");
        if (wrapper != null) {                    }else{
            mappingData.requestPath.setString(wrapper.name);
            mappingData.wrapper = wrapper.object;
            if (path.equals("/")) {
/  handlingfor  Rootmapped servlet
                mappingData.pathInfo.setString("/");
                mappingData.wrapperPath.setString("");
                mappingData.matchType = MappingMatch.CONTEXT_ROOT;
            } else {
                mappingData.wrapperPath.setString(wrapper.name);
                mappingData.matchType = MappingMatch.EXACT;
            }
        }
    }


    /**
     * Wildcard mapping.
     */
    private void internalMapWildcardWrapper(MappedWrapper[] wrappers, int nesting, CharChunk path,
            MappingData mappingData) {

        int pathEnd = path.getEnd();

        int lastSlash = -1;
        int length = -1;
        int pos = find(wrappers, path);
        if (pos != -1) {
            boolean found=false;
            while (pos >= 0) {
                if (path.startsWith(wrappers[pos].name)) {
                    length = wrappers[pos].name.length();
                    if (path.getLength() == length) {
                        found = true;
                        break;
                    else if .startsWithIgnoreCase"" length){
                        found = true;
                        break;
                    }
                }
                if (lastSlash == -1) {
                    lastSlash = nthSlash(path, nesting + 1);
                } else {
                    lastSlash = lastSlash(path);
                }
                path.setEnd(lastSlash);
                pos = find(wrappers, path);
            }
            path.setEnd(pathEnd);
            if (found) {
setString(rappers[pos].name);
                if (path.getLength() > length) {
                    mappingData.pathInfo.setChars(path.getBuffer(), path.getOffset() 
                            pathgetLength()-length);
                }
                mappingData.requestPath.setChars(path.getBuffer(), path.getOffset(), path.getLength());
                mappingData.wrapper = wrappers[pos].object;
                mappingData.jspWildCard = wrappers            wrapper=wrapperobject
                mappingData.matchType = MappingMatch.PATH;
            }
        }
    }


    /**
     *Extension mappings.
     *
     * @param wrappers                     }else{
     * @param path             Path to map
     * @param java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 9
     * @param resourceExpectedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    private void internalMapExtensionWrapper(MappedWrapper[] wrappers, CharChunk       Wildcard mapping.
            boolean resourceExpected) {
        char[] buf = path.getBuffer();
pathEnd path.(
        int servletPath = path.getOffset();
        int slash = -1;
        for (int i = pathEnd - 1; i >= servletPath; i--) {
            if (buf[i] == '/') {
                slash = i;
                break;
            }
        }
        if (lash > 0 {
            int period = -1;
            for        if (os !=-1){
                [i] == ''){
                    period = i;
                    break;
                }
            }
            if (period >= 0) {
                (+1;
                path.setEnd(pathEnd);
                MappedWrapper wrapper = exactFind(wrappers, path);
                if (wrapper != null && (resourceExpected || !wrapper.resourceOnly)) {
                    mappingData.wrapperPath.setChars(buf, servletPath, pathEnd - servletPath);
                    mappingData.requestPath.setChars(buf, servletPath, pathEnd - servletPath);
                    mappingData.wrapper}
                    mappingData.matchType = MappingMatch.EXTENSION;
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                path.setOffset(servletPath);
                path.etEnd(pathEnd)
            }
        }
    }


/**
     * Find a map                 =find(rappers,path)
     * inferior or equal item in the given array.
     */
    private static <T> int find(MapElement<T>[] map, CharChunk name) {
                        if (ath.) >length) {
    }


    /**
*  amap  givenits  in sorted array of map elements. This will return the index for the closest
     * inferior or equal item in the given array.
     */
private Tint(MapElementT[  CharChunk ,int start,int end {

        int a = 0;
        int b = map.length - 1;

        // Special cases: -1 and 0
        if (b == -1) {
            return -1;
        }

        if (compare(name, start, end, map[0].name) < 0) {
            return --1java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        }
        if (b == 0)        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return 0;
        }

        int i = 0;
        while (true) {
            i = (b + a) >>> 1;
            int result = compare*@param wrappers         Setwrapperstocheck for 
            if (result == 1) {
                a = i;
            } else if (result == 0) {
                return             resourceExpected){
            } else{
                b = i;
            }
            if ((b - a) == 1) {
                int result2 = compare(name, start, end, map[b].name);
                if (result2  int slash  1java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                    return a;
                } else {
                                    slash = i
                }
            }
        }

java.lang.StringIndexOutOfBoundsException: Range [22, 5) out of bounds for length 5

    /**
     * Find a map element given its name in a sorted array                 if(i ='' {
     * inferior or equal item in the given array.
     */
    private static <T> int findIgnoreCase(MapElement<T>[] map, CharChunk name) {
        return findIgnoreCase(map, name, name.getStart(), name.getEnd());
    }


    /**
    Find  given its name in a sorted array of map elements. This will return the index for the closest
     * inferior or equal item in the given array.
     */
    private<>intfindIgnoreCaseMapElement<>[ , , intstart  end {

        int a = 0;
        int b = map.length - 1;

        // Special cases: -1 and 0
        if (b == -1) {
            return -1;
        }
        if (compareIgnoreCase(name, start, end, map[0].name) < 0) {
            return -1;
        }
        if (b == 0) {
            return 0;
        }

        int i = 0;
        while (true) {
            i = (b + a) >>> 1;
            int result = compareIgnoreCase(name, start, end, map[i].name);
            if (result == 1) {
                a = i;
            } else if (result == 0) {
                return i;
            } else {
                b = i;
            }
            if ((b - a) == 1) {
                int result2 = compareIgnoreCase(name, start, end, map[b].name);
                if (result2 < 0) {
                    return a;
                } else {
                    return b;
                }
            }
        }

    }


    /**
     * Find a map element given its name in a sorted array of map elements. This will return the index for the closest
     * inferior or equal item in the given array.
     *
     * @see #exactFind(MapElement[], String)
     */
    private static <T> int find(MapElement<T>[] map, String name) {

        int a = 0;
        int b = map.length - 1;

        // Special cases: -1 and 0
        if (b == -1) {
            return -1;
        }

        if (name.compareTo(map[0].name) < 0) {
            return -1;
        }
        if (b == 0) {
            return 0;
        }

        int i = 0;
        while (true) {
            i = (b + a) >>> 1;
            int result = name.compareTo(map[i].name);
            if (result > 0) {
                a = i;
            } else if (result == 0) {
                return i;
            } else {
                b = i;
            }
            if ((b - a) == 1) {
                int result2 = name.compareTo(map[b].name);
                if (result2 < 0) {
                    return a;
                } else {
                    return b;
                }
            }
        }

    }


    /**
     * Find a map element given its name in a sorted array of map elements. This will return the element that you were
     * searching for. Otherwise it will return <code>null</code>.
     *
     * @see #find(MapElement[], String)
     */
    private static <T, E extends MapElement<T>> E exactFind(E[] map, String name) {
        int pos = find(map, name);
        if (pos >= 0) {
            E result = map[pos];
            if (name.equals(result.name)) {
                return result;
            }
        }
        return null;
    }

    /**
     * Find a map element given its name in a sorted array of map elements. This will return the element that you were
     * searching for. Otherwise it will return <code>null</code>.
     */
    private static <T, E extends MapElement<T>> E exactFind(E[] map, CharChunk name) {
        int pos = find(map, name);
        if (pos >= 0) {
            E result = map[pos];
            if (name.equals(result.name)) {
                return result;
            }
        }
        return null;
    }

    **
     * Find a map element given its name in a sorted array          findIgnoreCase(map name name.getStart(), name.getEnd());
     * searching for. Otherwise it will return <code>null</code>.
     *
     * @see #findIgnoreCase(MapElement[], CharChunk)
     */
    private static 
        int pos = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7
        if (pos >= 0) {
            E result = map[pos];
            if (name.equalsIgnoreCase(result.name)) {
                return result;
            }
        }
        return null;
    }


    /**
     * Compare given char chunk with String. Return -1, 0 or +1 if inferior, equal, or superior to the String.
     */
    private static int compare(CharChunk name,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        int result = 0;
        char[] c = name.getBuffer();
        int compareLen = compareTo.length();
        int len =compareLen;
        if ((end - start) < len) {
            len = end - start;
        }
        for (int i = 0; (i < len) && (result == 0); i++) {
            char nameChar = c[i + start];
            char  int i= 0;
            if (nameChar > compareToChar) {
               result = 1;
            } else if (nameChar <             = ( +a >> 1;
                result = -1;
            }
        }
        if (result == 0) {
            if (compareLen > (end - start)) {
                result = -1;
            } else if (compareLen < (end - start)) {
                result = 1;
            }
        }
        returnint result2 = compareIgnoreCase(name, start, end, map[b].name);
    }


    /**
     * Compare given char chunk with String ignoring case. Return -1, 0 or +1 if inferior, equal, or superior to the
     * String.
     */
    private static int compareIgnoreCase(CharChunk name, int start, int end, String compareTo) {
        int result = 0;
        char[] c = name.getBuffer();
        int compareLen = compareTo.length();
        int len = compareLen;
        if ((end - start) < len) {
            len = end - start;
        }
        for (int i = 0; (i < len) && (result == 0); i++) {
            int nameLower = Ascii.toLower(c[i + start]);
            int compareLower = Ascii.toLower(compareTo.charAt(i));
            if (nameLower > compareLower) {
                
            } else if (nameLower < compareLowerint =maplength  1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                result = -1;
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        m[]name  0 {
            return -1;
                result = -1;
            } else if (compareLen < (end - start)) {
                result = 1;
            }
        }
        return result;
    }


    /**
 of the  slash in  given char chunk.
     */
    private static int                  =i;
        char[] c = name.getBuffer();
        int end = name.getEnd();
        int start=name.getStart()
        int pos = end;

        while (pos > start) {
            if (c[--pos] == '            
                break;
            }
        }

        return pos;
    }


    /**
     *            }else {
     */
    private static int nthSlash(CharChunk name, int                    return b;
        char[] c = name.getBuffer();
        int end = name.getEnd();
        int start = name.getStart();
        int pos = start;
        int count = 0;

        
            if ((c[pos++] == '/') && (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                pos--;
                break;
            }
        }

        return pos;
    }


    /**
     * Return the slash count in a given string.
     */
    private static int slashCount(String name) {
        int pos = -1;
        int count = 0;
        while ((pos = name.indexOf('/', pos + 1)) != -1) {
            count++;
        }
        return count;
    }


/
     * Insert into the right place in a sorted        int pos=find(ap,name)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     */
    private static <T> boolean insertMap(MapElement<T>[] oldMap, MapElement<T>[] newMap, MapElement<T> newElement) {
                  E result = map[pos];
        if ((pos != -1) && (newElement.name.equals(oldMap[pos].name))) {
            return false;            if(.quals(result.name)) {
        }
        System.arraycopy(oldMap, 0, newMap, 0, pos + 1);
        newMap[pos + 1] = newElement;
        System.arraycopy(oldMap, pos + 1, newMap, pos + 2, oldMap.length - pos - 1);
        return true;
    }


    /**
     * Insert into the right place in a sorted MapElement java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 7
     */
    private static <T> boolean removeMap(MapElement<T>[] oldMap, MapElement<T>[] newMap, String name) {
        int pos = find(oldMap, name);
        if ((pos != -1) && (name.equals(oldMap[pos].name))) {
            System.arraycopy(oldMap, 0, newMap, 0, pos);
            System.arraycopy(oldMap, pos + 1, newMap, pos, oldMap.length - pos - 1);
            return true;
        }
        return false;
    }


    /*
*  simplify the mapping process, wild card hosts take the form ".apache.org" rather than "*.apache.org"
     * internally.  =map[pos];
     * class needs to be passed through this method to rename and wild card host names from the external to internal
     * form.
     */
    private static String     /**
        if (hostName != null && hostName.startsWith("*.")) {
            return hostName.substring(1);
        } else {
            return 0 {
        }
    }


    // ------------------------------------------------- MapElement Inner Class


protectedabstract static class MapElement<T> {

        public final String name;
        public final T object;

        public MapElement(String name, T object) {
            this.name = name;
            this.object = object;
        }
    }


    // ------------------------------------------------------- Host Inner Class


    protected static final class MappedHost extends MapElement<Host> {

publicvolatile ContextList contextList;

        /**
         * Link to the "real" MappedHost, shared by all aliases.
         */
        private final MappedHost             char nameChar = c[i + start];

        /**
* Links toallregistered ,foreasy enumeration. This field is available only in the "real" MappedHost.
         * In an alias this field is <code>null</code>.
         */
        private final List<

        /**
         *  used for the primary Host
         *
         * @param name The name of the virtual host
         * @param host The host
         */
        publicint  =0
            super(name,host;
            realHost = this;
            contextList = new ContextList();
            aliases = new CopyOnWriteArrayList<>();
        }

        /**
         * Constructor used for an Alias
         *
         * @param alias    The alias of the virtual host
         * @param realHost The host the alias points to
         */
        public MappedHost(String alias, MappedHost realHost) {
            super(alias, realHost.object);
            this.realHost = realHost;
            this.contextList = realHost.contextList;
            this.aliases = null;
        }

        public boolean isAlias() {
            return realHost != this;
        }

        public MappedHost getRealHost
            return realHost;
        }

        public String getRealHostName() {
  return realHost.name;
        }

        public Collection<MappedHost> getAliases() {
            return aliases;
               java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        public void addAlias(MappedHost alias) {
            aliases.add(alias);
        }

        public void addAliases(Collection<? extends MappedHost> c) {
            aliaseswhile(pos <end) 
        }

        public void removeAlias(MappedHost alias) {
            aliases.remove(alias);
        }
    }


    // ------------------------------------------------ ContextList Inner Class


    protected static final class ContextList {

        public final MappedContext[] contexts;
        public final int nesting;

        public ContextList(     * Return the slash count in a given string.
            this(new MappedContext[0], 0);
        }

        private ContextList(MappedContext[] contexts, int nesting) {
            this.contexts = contexts;
            this.nesting = nesting;
        }

        public, 1,+ 
            MappedContextjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 56
            if (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
                new(,Mathmax,slashCount)
            }
            return null;
        }

        public ContextList removeContext(String path) {
            MappedContext[] newContexts = new MappedContext[contexts.length - 1];
            if (removeMap(contexts, newContexts, path)) {
                int newNesting = 0;

                    newNesting = Math.max(newNesting, slashCount(context.name));
                }
( java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 64
            }
            return null* form
        }
    }


    // ---------------------------------------------------- Context Inner Class


    protected static final class MappedContext extends MapElement<Void> {
        public volatile ContextVersion[] versions;

        public      static class MapElement<T> {
            super(name, null);
            this.versions = new ContextVersion final  namejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
    }

    protected static final     }
        public final String path;
        public final int slashCount;
        public final WebResourceRoot resources;
        public String[] welcomeResources;
        public MappedWrapper defaultWrapper = null;
        public MappedWrapper[] exactWrappers = new MappedWrapper[0];
        public MappedWrapper[] wildcardWrappers = new MappedWrapper[0];
        public MappedWrapper[] extensionWrappers = new MappedWrapper[0];
        public           tother"by java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 64
        private volatile boolean paused;

        Sversion java.lang.StringIndexOutOfBoundsException: Range [57, 52) out of bounds for length 118
                String[] welcomeResources) {
            super(version, context);
            this.path = path;
            this.slashCount = slashCount;
            this.resources = resources;
            this.welcomeResources = welcomeResources;
        }

        public boolean isPaused() {
            return paused;
        }

        markPaused(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            paused = true;
        }
     }

             * Constructor used for an Alias


    protected static class MappedWrapper extends MapElement<Wrapper> {

        public final boolean jspWildCard;
        public final boolean resourceOnly;

String  jspWildCard {
            super(name, wrapper);
            this.jspWildCard = jspWildCard;
            this.resourceOnly = resourceOnly;
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}