Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Licensed to the Apache Software Foundation (ASF) under one or more
   *  contributor license agreements.  See the NOTICE file distributed with
   *  this work for additional information regarding copyright ownership.
   *  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 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.apache.tomcat.websocket.server;
 
 import static org.jboss.web.WebsocketsMessages.MESSAGES;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
Extracts path parameters from URIs used to create web socket connections using the URI template defined for the associated Endpoint.
 
 public class UriTemplate {
 
     private final String normalized;
     private final List<Segmentsegments = new ArrayList<Segment>();
     private final boolean hasParameters;
 
 
     public UriTemplate(String paththrows DeploymentException {
 
         if (path == null || path.length() ==0 || !path.startsWith("/")) {
             throw new DeploymentException(.invalidPath(path));
         }
 
         StringBuilder normalized = new StringBuilder(path.length());
         Set<StringparamNames = new HashSet<String>();
 
         // Include empty segments.
         String[] segments = path.split("/", -1);
         int paramCount = 0;
         int segmentCount = 0;
 
         for (int i = 0; i < segments.lengthi++) {
             String segment = segments[i];
             if (segment.length() == 0) {
                 if (i == 0 || (i == segments.length - 1 && paramCount == 0)) {
                     // Ignore the first empty segment as the path must always
                     // start with '/'
                     // Ending with a '/' is also OK for instances used for
                     // matches but not for parameterised templates.
                     continue;
                 } else {
                     // As per EG discussion, all other empty segments are
                     // invalid
                     throw .invalidEmptySegment(path);
                 }
             }
             normalized.append('/');
             int index = -1;
             if (segment.startsWith("{") && segment.endsWith("}")) {
                 index = segmentCount;
                 segment = segment.substring(1, segment.length() - 1);
                 normalized.append('{');
                 normalized.append(paramCount++);
                 normalized.append('}');
                 if (!paramNames.add(segment)) {
                     throw .duplicateParameter(segment);
                 }
             } else {
                 if (segment.contains("{") || segment.contains("}")) {
                     throw .invalidPathSegment(segmentpath);
                 }
                 normalized.append(segment);
             }
             this..add(new Segment(indexsegment));
             segmentCount++;
         }
 
         this. = normalized.toString();
         this. = paramCount > 0;
     }
 
 
     public Map<String,Stringmatch(UriTemplate candidate) {
 
         Map<String,Stringresult = new HashMap<StringString>();
        // Should not happen but for safety
        if (candidate.getSegmentCount() != getSegmentCount()) {
            return null;
        }
        Iterator<SegmentcandidateSegments =
                candidate.getSegments().iterator();
        Iterator<SegmenttargetSegments = .iterator();
        while (candidateSegments.hasNext()) {
            Segment candidateSegment = candidateSegments.next();
            Segment targetSegment = targetSegments.next();
            if (targetSegment.getParameterIndex() == -1) {
                // Not a parameter - values must match
                if (!targetSegment.getValue().equals(
                        candidateSegment.getValue())) {
                    // Not a match. Stop here
                    return null;
                }
            } else {
                // Parameter
                result.put(targetSegment.getValue(),
                        candidateSegment.getValue());
            }
        }
        return result;
    }
    public boolean hasParameters() {
        return ;
    }
    public int getSegmentCount() {
        return .size();
    }
    public String getNormalizedPath() {
        return ;
    }
    private List<SegmentgetSegments() {
        return ;
    }
    private static class Segment {
        private final int parameterIndex;
        private final String value;
        public Segment(int parameterIndexString value) {
            this. = parameterIndex;
            this. = value;
        }
        public int getParameterIndex() {
            return ;
        }
        public String getValue() {
            return ;
        }
    }
New to GrepCode? Check out our FAQ X