Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2004-2005 Graeme Rocher
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.codehaus.groovy.grails.web.mapping;
 
 import java.util.List;
 
Default implementating of the UrlMappingData interface.

Author(s):
Graeme Rocher
Since:
0.4
 
 public class DefaultUrlMappingData implements UrlMappingData {
 
     private static final String CAPTURED_WILDCARD = "(*)";
     private static final String CAPTURED_DOUBLE_WILDCARD = "(**)";
     private static final String QUESTION_MARK = "?";
     private static final String SLASH = "/";
 
     private final String urlPattern;
     private final String[] logicalUrls;
     private final String[] tokens;
 
     private List<BooleanoptionalTokens = new ArrayList<Boolean>();
     private boolean hasOptionalExtension;
 
     public DefaultUrlMappingData(String urlPattern) {
         Assert.hasLength(urlPattern"Argument [urlPattern] cannot be null or blank");
         Assert.isTrue(urlPattern.startsWith(), "Argument [urlPattern] is not a valid URL. It must start with '/' !");
 
         String configuredPattern = configureUrlPattern(urlPattern);
         this. = configuredPattern;
          = tokenizeUrlPattern(configuredPattern);
         List<Stringurls = new ArrayList<String>();
         parseUrls(urls);
 
          = urls.toArray(new String[urls.size()]);
     }
 
     @Override
     public boolean hasOptionalExtension() {
         return ;
     }
 
     private String[] tokenizeUrlPattern(String urlPattern) {
         // remove starting / and split
         return urlPattern.substring(1).split();
     }
 
     private String configureUrlPattern(String urlPattern) {
         return StringUtils.replace(urlPattern"(*)**");
     }
 
     private DefaultUrlMappingData(String urlPatternString[] logicalUrlsString[] tokensList<BooleanoptionalTokens) {
         this. = urlPattern;
         this. = logicalUrls;
         this. = tokens;
         this. = optionalTokens;
     }
 
     private void parseUrls(List<StringurlsString[] tokensList<BooleanoptionalTokens) {
         StringBuilder buf = new StringBuilder();
 
 
         String optionalExtensionPattern = . + '?';
         String optionalExtension = null;
 
         if(tokens.length>0) {
             String lastToken = tokens[tokens.length-1];
              = lastToken.endsWith(optionalExtensionPattern);
             if() {
                 int i = lastToken.indexOf(optionalExtensionPattern);
                 optionalExtension = lastToken.substring(ilastToken.length());
                 tokens[tokens.length-1] = lastToken.substring(0, i);
             }
 
         }
 
         for (int i = 0; i < tokens.lengthi++) {
             String token = tokens[i].trim();
             if (token.equals()) {
                continue;
            }
            boolean isOptional = false;
            if (token.endsWith()) {
                if(optionalExtension != null) {
                    urls.add(buf.toString() + optionalExtension);
                }
                else {
                    urls.add(buf.toString());
                }
                buf.append().append(token);
                isOptional = true;
            } else {
                buf.append().append(token);
            }
            if (.equals(token)) {
                if (isOptional) {
                    optionalTokens.add(.);
                } else {
                    optionalTokens.add(.);
                }
            }
            if (.equals(token)) {
                optionalTokens.add(.);
            }
        }
        if(optionalExtension != null) {
            urls.add(buf.toString() + optionalExtension);
        }
        else {
            urls.add(buf.toString());
        }
        Collections.reverse(urls);
    }
    public String[] getTokens() {
        return ;
    }
    public String[] getLogicalUrls() {
        return ;
    }
    public String getUrlPattern() {
        return ;
    }
    public boolean isOptional(int index) {
        if (index >= .size()) return true;
        return .get(index).equals(.);
    }
    @Override
    public UrlMappingData createRelative(String path) {
        Assert.hasLength(path"Argument [path] cannot be null or blank");
        String newPattern = this. + configureUrlPattern(path);
        String[] tokens = tokenizeUrlPattern(newPattern);
        List<Stringurls = new ArrayList<String>();
        List<BooleanoptionalTokens = new ArrayList<Boolean>();
        parseUrls(urlstokensoptionalTokens);
        String[] logicalUrls = urls.toArray(new String[urls.size()]);
        return new DefaultUrlMappingData(newPattern,logicalUrlstokens,optionalTokens);
    }
New to GrepCode? Check out our FAQ X