public DefaultActionMapper() 
{
        prefixTrie = new PrefixTrie() {
            {
                put(METHOD_PREFIX, new ParameterAction() {
                    public void execute(String key, ActionMapping mapping) {
                        if (allowDynamicMethodCalls) {
                            mapping.setMethod(key.substring(
                                                   METHOD_PREFIX.length()));
                        }
                    }
                });
                put(ACTION_PREFIX, new ParameterAction() {
                    public void execute(String key, ActionMapping mapping) {
                        String name = key.substring(ACTION_PREFIX.length());
                        if (allowDynamicMethodCalls) {
                            int bang = name.indexOf('!');
                            if (bang != -1) {
                                String method = name.substring(bang + 1);
                                mapping.setMethod(method);
                                name = name.substring(0, bang);
                            }
                        }
                        mapping.setName(name);
                    }
                });
                put(REDIRECT_PREFIX, new ParameterAction() {
                    public void execute(String key, ActionMapping mapping) {
                        ServletRedirectResult redirect = new ServletRedirectResult();
                        container.inject(redirect);
                        redirect.setLocation(key.substring(REDIRECT_PREFIX
                                .length()));
                        mapping.setResult(redirect);
                    }
                });
                put(REDIRECT_ACTION_PREFIX, new ParameterAction() {
                    public void execute(String key, ActionMapping mapping) {
                        String location = key.substring(REDIRECT_ACTION_PREFIX
                                .length());
                        ServletRedirectResult redirect = new ServletRedirectResult();
                        container.inject(redirect);
                        String extension = getDefaultExtension();
                        if (extension != null && extension.length()  > 0) {
                            location += "." + extension;
                        }
                        redirect.setLocation(location);
                        mapping.setResult(redirect);
                    }
                });
            }
        };
}

 protected  void addParameterAction(String prefix,
    ParameterAction parameterAction) 
{
        prefixTrie.put(prefix, parameterAction);
}

Adds a parameter action. Should only be called during initialization

 protected String dropExtension(String name) 
{
        return dropExtension(name, new ActionMapping());
}

Drops the extension from the action name

 protected String dropExtension(String name,
    ActionMapping mapping) 
{
        if (extensions == null) {
            return name;
        }
        for (String ext : extensions) {
            if ("".equals(ext)) {
                // This should also handle cases such as /foo/bar-1.0/description. It is tricky to
                // distinquish /foo/bar-1.0 but perhaps adding a numeric check in the future could
                // work
                int index = name.lastIndexOf('.');
                if (index == -1 || name.indexOf('/', index)  >= 0) {
                    return name;
                }
            } else {
                String extension = "." + ext;
                if (name.endsWith(extension)) {
                    name = name.substring(0, name.length() - extension.length());
                    mapping.setExtension(ext);
                    return name;
                }
            }
        }
        return null;
}

Drops the extension from the action name, storing it in the mapping for later use

 protected String getDefaultExtension() 
{
        if (extensions == null) {
            return null;
        } else {
            return (String) extensions.get(0);
        }
}

Returns null if no extension is specified.

 public ActionMapping getMapping(HttpServletRequest request,
    ConfigurationManager configManager) 
{
        ActionMapping mapping = new ActionMapping();
        String uri = getUri(request);
        int indexOfSemicolon = uri.indexOf(";");
        uri = (indexOfSemicolon  > -1) ? uri.substring(0, indexOfSemicolon) : uri;
        uri = dropExtension(uri, mapping);
        if (uri == null) {
            return null;
        }
        parseNameAndNamespace(uri, mapping, configManager);
        handleSpecialParameters(request, mapping);
        if (mapping.getName() == null) {
            return null;
        }
        parseActionName(mapping);
        return mapping;
}

 public ActionMapping getMappingFromActionName(String actionName) 
{
        ActionMapping mapping = new ActionMapping();
        mapping.setName(actionName);
        return parseActionName(mapping);
}

 protected String getUri(HttpServletRequest request) 
{
        // handle http dispatcher includes.
        String uri = (String) request
                .getAttribute("javax.servlet.include.servlet_path");
        if (uri != null) {
            return uri;
        }
        uri = RequestUtils.getServletPath(request);
        if (uri != null && !"".equals(uri)) {
            return uri;
        }
        uri = request.getRequestURI();
        return uri.substring(request.getContextPath().length());
}

Gets the uri from the request

 public String getUriFromActionMapping(ActionMapping mapping) 
{
        StringBuilder uri = new StringBuilder();
        if (mapping.getNamespace() != null) {
            uri.append(mapping.getNamespace());
            if (!"/".equals(mapping.getNamespace())) {
                uri.append("/");
            }
        }
        String name = mapping.getName();
        String params = "";
        if (name.indexOf('?') != -1) {
            params = name.substring(name.indexOf('?'));
            name = name.substring(0, name.indexOf('?'));
        }
        uri.append(name);
        if (null != mapping.getMethod() && !"".equals(mapping.getMethod())) {
            uri.append("!").append(mapping.getMethod());
        }
        String extension = mapping.getExtension();
        if (extension == null) {
            extension = getDefaultExtension();
            // Look for the current extension, if available
            ActionContext context = ActionContext.getContext();
            if (context != null) {
                ActionMapping orig = (ActionMapping) context.get(ServletActionContext.ACTION_MAPPING);
                if (orig != null) {
                    extension = orig.getExtension();
                }
            }
        }
        if (extension != null) {
            if (extension.length() == 0 || (extension.length()  > 0 && uri.indexOf('.' + extension) == -1)) {
                if (extension.length()  > 0) {
                    uri.append(".").append(extension);
                }
                if (params.length()  > 0) {
                    uri.append(params);
                }
            }
        }
        return uri.toString();
}

 public  void handleSpecialParameters(HttpServletRequest request,
    ActionMapping mapping) 
{
        // handle special parameter prefixes.
        Set< String > uniqueParameters = new HashSet< String >();
        Map parameterMap = request.getParameterMap();
        for (Iterator iterator = parameterMap.keySet().iterator(); iterator
                .hasNext();) {
            String key = (String) iterator.next();
            // Strip off the image button location info, if found
            if (key.endsWith(".x") || key.endsWith(".y")) {
                key = key.substring(0, key.length() - 2);
            }
            // Ensure a parameter doesn't get processed twice
            if (!uniqueParameters.contains(key)) {
                ParameterAction parameterAction = (ParameterAction) prefixTrie
                        .get(key);
                if (parameterAction != null) {
                    parameterAction.execute(key, mapping);
                    uniqueParameters.add(key);
                    break;
                }
            }
        }
}

Special parameters, as described in the class-level comment, are searched for and handled.

 public boolean isSlashesInActionNames() 
{
		return allowSlashesInActionNames;
}

 protected ActionMapping parseActionName(ActionMapping mapping) 
{
        if (mapping.getName() == null) {
            return mapping;
        }
        if (allowDynamicMethodCalls) {
            // handle "name!method" convention.
            String name = mapping.getName();
            int exclamation = name.lastIndexOf("!");
            if (exclamation != -1) {
                mapping.setName(name.substring(0, exclamation));
                mapping.setMethod(name.substring(exclamation + 1));
            }
        }
        return mapping;
}

 protected  void parseNameAndNamespace(String uri,
    ActionMapping mapping,
    ConfigurationManager configManager) 
{
        String namespace, name;
        int lastSlash = uri.lastIndexOf("/");
        if (lastSlash == -1) {
            namespace = "";
            name = uri;
        } else if (lastSlash == 0) {
            // ww-1046, assume it is the root namespace, it will fallback to
            // default
            // namespace anyway if not found in root namespace.
            namespace = "/";
            name = uri.substring(lastSlash + 1);
        } else if (alwaysSelectFullNamespace) {
            // Simply select the namespace as everything before the last slash
            namespace = uri.substring(0, lastSlash);
            name = uri.substring(lastSlash + 1);
        } else {
            // Try to find the namespace in those defined, defaulting to ""
            Configuration config = configManager.getConfiguration();
            String prefix = uri.substring(0, lastSlash);
            namespace = "";
            boolean rootAvailable = false;
            // Find the longest matching namespace, defaulting to the default
            for (Object cfg : config.getPackageConfigs().values()) {
                String ns = ((PackageConfig) cfg).getNamespace();
                if (ns != null && prefix.startsWith(ns) && (prefix.length() == ns.length() || prefix.charAt(ns.length()) == '/')) {
                    if (ns.length()  > namespace.length()) {
                        namespace = ns;
                    }
                }
                if ("/".equals(ns)) {
                    rootAvailable = true;
                }
            }
            name = uri.substring(namespace.length() + 1);
            // Still none found, use root namespace if found
            if (rootAvailable && "".equals(namespace)) {
                namespace = "/";
            }
        }
        if (!allowSlashesInActionNames && name != null) {
            int pos = name.lastIndexOf('/');
            if (pos  > -1 && pos <  name.length() - 1) {
                name = name.substring(pos + 1);
            }
        }
        mapping.setNamespace(namespace);
        mapping.setName(name);
}

Parses the name and namespace from the uri

 public  void setAllowDynamicMethodCalls(String allow) 
{
        allowDynamicMethodCalls = "true".equals(allow);
}

 public  void setAlwaysSelectFullNamespace(String val) 
{
        this.alwaysSelectFullNamespace = "true".equals(val);
}

 public  void setContainer(Container container) 
{
        this.container = container;
}

 public  void setExtensions(String extensions) 
{
        if (extensions != null && !"".equals(extensions)) {
            List< String > list = new ArrayList< String >();
            String[] tokens = extensions.split(",");
            for (String token : tokens) {
                list.add(token);
            }
            if (extensions.endsWith(",")) {
                list.add("");
            }
            this.extensions = Collections.unmodifiableList(list);
        } else {
            this.extensions = null;
        }
}

 public  void setSlashesInActionNames(String allow) 
{
        allowSlashesInActionNames = "true".equals(allow);
}